Erstelle einen Chatbot mit einer LLM-API: Python-Tutorial
Abliterated-Modelle sind große Sprachmodelle, bei denen die Mechanismen zur Erzwingung von Sicherheitsablehnungen entfernt wurden, sodass das Modell kontroverse, erwachsene oder Nischenfragen beantworten kann, ohne auf einen Inhaltsfilter zu stoßen. Dieser Ansatz gibt Entwicklern die volle Kontrolle über die Stimme und den Wissensstand des Modells, was besonders für Coding, Rollenspiele und kreatives Schreiben wertvoll ist, bei dem Standard-Sicherheitsmechanismen nützliche Ausgaben blockieren könnten.
Aktualisiert
Wichtige Punkte
- Die API ist zustandslos, daher besitzt dein Code den Konversationsverlauf und sendet ihn bei jeder Anfrage.
- Streaming, Tool-Calling und JSON-Modus verwenden alle die Standard-OpenAI-Parameter.
- Kürze oder fasse den Verlauf zusammen, bevor er sich dem 100.000-Token-Fenster nähert.
- 1.000 Chats mit 2.000 Input-Token und 400 Output-Token kosten etwa 0,50 $.
Die Kernidee: Ein Chatbot ist eine Schleife und eine Liste
Ein Sprachmodell erinnert sich an nichts zwischen den Anfragen. Jeder Aufruf von POST /v1/chat/completions ist unabhängig. Was wie Speicher wirkt, ist dein Programm, das die früheren Nachrichten erneut sendet, jeweils mit einer Rolle versehen: system für Anweisungen, user für das, was der Benutzer eingegeben hat, assistant für frühere Antworten des Modells.
Die gesamte Architektur ist also klein. Halte eine Liste. Hänge die Benutzernachricht an. Sende die Liste. Hänge die Antwort an. Wiederhole. Alles andere in diesem Tutorial, vom Streaming bis zu den Tools, ist eine Variation dieser Schleife.
Die API hier ist OpenAI-kompatibel, daher verwendest du das reguläre openai-Paket. Setze die Base URL auf https://api.abliterated.cc/v1, verwende deinen Schlüssel und setze das Modell auf uncensored. Hole dir einen Schlüssel von der API-Schlüssel-Seite; das 0,50-$-Testguthaben reicht für viele hundert kurze Testnachrichten.
Schritt 1: Ein funktionierender Konsolen-Chatbot
Installiere das SDK mit pip install openai und führe dies aus.
from openai import OpenAI
client = OpenAI(
base_url="https://api.abliterated.cc/v1",
api_key="YOUR_KEY",
)
messages = [
{"role": "system", "content": "You are a concise, friendly support assistant for a bike shop."}
]
while True:
text = input("you: ")
if text.strip() in {"quit", "exit"}:
break
messages.append({"role": "user", "content": text})
resp = client.chat.completions.create(
model="uncensored",
messages=messages,
temperature=0.7,
)
answer = resp.choices[0].message.content
messages.append({"role": "assistant", "content": answer})
print("bot:", answer)
Das ist ein vollständiger Chatbot. Die Systemnachricht definiert seine Aufgabe, die Liste enthält den Speicher, und temperature steuert, wie vielfältig die Antworten sind. Senke ihn auf etwa 0,2 für faktische Support-Bots, erhöhe ihn auf etwa 1,0 für kreative.
Schreibe einen System-Prompt, der die Aufgabe definiert
Die Systemnachricht ist die günstigste Stelle, um einen Chatbot zu verbessern. Halte sie kurz und spezifisch. Nenne die Rolle, das Zielpublikum, die Länge und den Ton der Antworten sowie das Verhalten, wenn der Bot etwas nicht weiß. Ein Prompt wie „Du beantwortest Fragen für einen Fahrradladen. Antworte in maximal drei Sätzen. Geht es um Reparaturkosten, sage, dass ein Mechaniker das Fahrrad prüfen muss“ leistet mehr als eine Seite allgemeiner Tugenden.
Zwei Gewohnheiten lohnen sich. Erstens, formuliere Regeln als Aktionen, nicht als Einstellungen: „Stelle eine Rückfrage, wenn die Anfrage mehrdeutig ist“ statt „Sei hilfsbereit“. Zweitens, teste mit feindseligen Eingaben, wie einer leeren Nachricht, einem sehr langen Text und einer Anfrage, die nichts mit deinem Produkt zu tun hat. Passe den Prompt basierend auf dem Gesehenen an und behalte diese Eingaben als Regressionstestliste.
Da die Systemnachricht bei jedem Durchgang erneut gesendet wird, wird jedes Wort darin bei jeder Anfrage abgerechnet. Ein 400-Token-Prompt über 1.000 Chats mit jeweils 5 Durchgängen fügt 2.000.000 Input-Token hinzu, oder 2 x 0,15 $ = 0,30 $. Das ist wenig, zeigt aber, warum aufgeblähte Prompts bei hohem Volumen summieren.
Schritt 2: Antwort streamen
Auf eine vollständige Antwort zu warten, fühlt sich in einem Chat-Fenster langsam an. Setze stream: true und gib Fragmente aus, sobald sie eintreffen. Der Stream nutzt Server-Sent Events und endet mit einem Nutzungsbereich, sodass du Token-Anzahlen protokollieren kannst.
from openai import OpenAI
client = OpenAI(base_url="https://api.abliterated.cc/v1", api_key="YOUR_KEY")
messages = [{"role": "user", "content": "Explain tire pressure in two sentences."}]
stream = client.chat.completions.create(
model="uncensored",
messages=messages,
stream=True,
)
reply = ""
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
part = chunk.choices[0].delta.content
reply += part
print(part, end="", flush=True)
if getattr(chunk, "usage", None):
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Vergiss nicht, die zusammengesetzte reply-Antwort an deinen Verlauf anzuhängen, sonst weiß der nächste Durchgang nicht, was der Bot gesagt hat.
Schritt 3: Kontext verwalten, bevor er wächst
Das Kontextfenster umfasst 100.000 Token, geteilt zwischen Prompt und Vervollständigung. Die meisten Chatbots erreichen das nie, aber die Kosten steigen mit dem Verlauf, da du für den gesamten Prompt bei jedem Durchgang zahlst. Eine einfache Strategie hält beides im Zaum:
- Behalte immer die Systemnachricht.
- Behalte die letzten 10 bis 20 Nachrichten wörtlich.
- Wenn die Liste eine von dir gewählte Größenbegrenzung überschreitet, z. B. 8.000 geschätzte Token, sende den ältesten Block an das Modell mit der Anweisung „Fasse diese Unterhaltung in weniger als 150 Worten zusammen“ und ersetze diesen Block durch die Zusammenfassung als Systemnachricht.
Eine grobe Schätzung von einem Token pro vier englischen Zeichen reicht für den Auslöser. Die Nutzungszahlen in jeder Antwort geben dir die genaue Zahl nachträglich, sodass du die Grenze kalibrieren kannst.
Wenn du durch Löschen der ältesten Nachrichten kürzt, lösche sie in User- und Assistenten-Paaren. Eine Antwort ohne Frage oder eine Frage ohne Antwort verwirrt das Modell mehr, als man erwarten würde.
Schritt 4: Dem Bot Werkzeuge geben
Tool-Calling ermöglicht es dem Modell, deinen Code etwas tun zu lassen, z. B. eine Bestellung nachzuschlagen. Du beschreibst Funktionen mit tools, das Modell antwortet mit einem tool_calls-Eintrag, du führst die Funktion aus und sendest das Ergebnis als Nachricht mit role: "tool" zurück.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.abliterated.cc/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up the status of an order by its id",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
},
}]
def get_order_status(order_id):
return {"order_id": order_id, "status": "shipped"}
messages = [{"role": "user", "content": "Where is order A1042?"}]
resp = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = resp.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = get_order_status(**args)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
Validiere immer die Argumente, bevor du etwas mit Seiteneffekten ausführst. Das Modell schlägt einen Aufruf vor; dein Code entscheidet, ob er ausgeführt wird.
Schritt 5: Strukturierte Ausgabe mit JSON-Modus
Wenn der nächste Schritt in deinem Programm Daten statt Text benötigt, z. B. das Sortieren einer Nachricht in eine Kategorie, verwende den JSON-Modus mit response_format. Erwähne das Wort JSON und die erwarteten Schlüssel auch in deinem Prompt.
curl https://api.abliterated.cc/v1/chat/completions \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"response_format": {"type": "json_object"},
"messages": [
{"role": "system", "content": "Reply with JSON: {\"intent\": string, \"urgent\": boolean}"},
{"role": "user", "content": "My brakes squeal and I ride tomorrow morning."}
]
}'
Packe json.loads dennoch in einen try-Block. Wenn das Parsing fehlschlägt, wiederhole den Vorgang einmal mit angehängtem Fehlertext; fehlgeschlagene Anfragen werden nicht berechnet.
Fehler, Kosten und Hinweise zur Bereitstellung
Behandle Fehler, Wiederholungen und Ratenlimits
Echte Benutzer senden Anfragen zu ungünstigen Zeitpunkten, und Netzwerke fallen aus. Verpacke den Aufruf, damit eine schlechte Antwort die Konversation nicht abstürzen lässt.
import time
from openai import OpenAI, APIError, RateLimitError
client = OpenAI(base_url="https://api.abliterated.cc/v1", api_key="YOUR_KEY")
def chat(messages, tries=3):
for attempt in range(tries):
try:
resp = client.chat.completions.create(
model="uncensored", messages=messages, temperature=0.7
)
return resp.choices[0].message.content
except RateLimitError:
time.sleep(2 ** attempt)
except APIError as exc:
if attempt == tries - 1:
raise
time.sleep(1)
return "Sorry, the assistant is busy. Please try again in a moment."
Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute; der Test-Schlüssel erlaubt 2 und 60. Wenn dein Bot vielen Benutzern gleichzeitig dient, stelle Anfragen in eine Warteschlange mit einem Worker-Limit unter 8, statt dich auf Retries zu verlassen. Da fehlgeschlagene Anfragen nicht berechnet werden, haben Retries keine Token-Kosten. Halte die Anzahl der Retries gering, damit ein echter Ausfall schnell fehlschlägt.
Logge auch den Header X-Request-Id bei jedem Nachrichtendurchlauf. Wenn eine Antwort falsch aussieht, lässt sich die Anfrage über die ID später genau finden.
Kosten und Bereitstellung
Der Preis beträgt 0,15 $ pro 1 Mio. Input-Token und 0,50 $ pro 1 Mio. Output-Token. Angenommen, ein Support-Chat verwendet insgesamt 2.000 Input-Token und 400 Output-Token.
- Input: 0,002 Mio. x 0,15 $ = 0,0003 $
- Output: 0,0004 Mio. x 0,50 $ = 0,0002 $
- Ein Chat: 0,0005 $, also kosten 1.000 Chats 0,50 $
Prüfe die aktuellen Raten und Auflade-Boni auf der Preisseite. Halte den Schlüssel in der Produktion auf deinem Server, niemals im Browser-Code, und beobachte den Header X-Balance-USD, um dich zu warnen, bevor das Guthaben ausgeht. Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute, also stelle Lastspitzen in eine Warteschlange, statt sie alle auf einmal abzufeuern. Die Dokumentation listet alle unterstützten Parameter auf.
Weitere Anleitungen
Fragen und Antworten
Brauche ich ein Framework, um einen Chatbot zu erstellen?
Nein. Für einen funktionierenden Bot reichen das OpenAI SDK und eine Nachrichtenliste. Füge erst später ein Framework hinzu, wenn du dessen Extras benötigst.
Merkt sich die API frühere Nachrichten?
Nein. Jede Anfrage ist unabhängig, daher muss dein Code den Verlauf jedes Mal erneut senden.
Wie verhindere ich, dass der Verlauf zu lang wird?
Behalte die Systemnachricht und die jüngsten Nachrichten, und fasse ältere in eine kurze Zusammenfassung zusammen, sobald die Liste eine von dir festgelegte Größe überschreitet.
Kann der Bot meine eigenen Funktionen aufrufen?
Ja. Übergib Tools und tool_choice, führe die Funktion aus, wenn die Antwort tool_calls enthält, und gib das Ergebnis als Tool-Nachricht zurück.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Base URL. Das ist die gesamte Einrichtung.
