KI-API-Entwicklung
Es ist praktisch, KI-Chat-Tools in einer Weboberfläche zu verwenden, aber um KI-Fähigkeiten wirklich in Ihre eigenen Produkte, Workflows und Automatisierungsskripte zu integrieren, benötigen Sie eine API.
Eine API (Application Programming Interface) ist eine Brücke für die Kommunikation zwischen Anwendungen. Über eine API kann Ihr Code direkt Anfragen an ein KI-Modell senden und Antworten empfangen, ohne dass Sie manuell eine Webseite öffnen und kopieren/einfügen müssen.
Stellen Sie sich diese Szenarien vor:
Ihre E-Commerce-Website generiert automatisch beschreibende Texte für jedes Produkt.
-
Ihre Notizen-App fasst automatisch lange Texte zusammen, die Benutzer eingegeben haben.
-
Ihr Kundenservice-System kategorisiert Benutzeranfragen automatisch und beantwortet sie.
-
All diese Funktionen können über KI-APIs implementiert werden.
Das Ziel dieses Moduls ist, Sie von "nur mit KI chatten zu können" zu "KI in Ihrem Code arbeiten lassen zu können" zu bringen.
Grundlegende API-Konzepte
Bevor Sie Code schreiben, sollten Sie zunächst einige Kernkonzepte verstehen.
Was ist eine API
Eine API ist eine Reihe vereinbarter Kommunikationsprotokolle. Wir senden Anfragen in einem bestimmten Format, und die andere Seite gibt Ergebnisse in einem bestimmten Format zurück.
Nehmen Sie als Analogie das Bestellen von Essen:
-
Sie betreten ein Restaurant, erhalten die Speisekarte (API-Dokumentation) und wissen, was Sie bestellen können und wie Sie bestellen (Anfrageformat).
-
Sie sagen zum Kellner: "Ein Kung Pao Chicken, weniger scharf" (Senden einer API-Anfrage).
-
Die Küche bereitet das Gericht zu und bringt es Ihnen (Zurückgeben der API-Antwort).
In diesem Prozess müssen Sie die Küche nicht betreten und auch nicht wissen, wie das Gericht zubereitet wird – das ist der Wert einer API:Komplexe Details kapseln, nur eine einfache Schnittstelle offenlegen。
REST-API-Grundlagen
REST (Representational State Transfer) ist derzeit der beliebteste API-Designstil.
Einfach gesagt, verwendet es das HTTP-Protokoll zur Kommunikation:
| HTTP-Methode | Zweck | Beispiel in KI-APIs |
|---|---|---|
| POST | Eine Ressource erstellen | Chat-Anfragen senden, Bilder generieren |
| GET | Eine Ressource abrufen | Modelllisten abfragen, Abrechnungsinformationen abrufen |
| DELETE | Eine Ressource löschen | Konversationsverlauf löschen |
Die überwiegende Mehrheit der KI-APIs verwendet POST-Anfragen, weil wir "Inhalte zur Verarbeitung an die KI senden" müssen.
JSON-Format-Grundlagen
JSON (JavaScript Object Notation) ist das am häufigsten verwendete Datenformat in der API-Kommunikation.
Die Syntax von JSON ist sehr einfach; sie ist eine Kombination aus Schlüssel-Wert-Paaren.
Beispiele
"model": "gpt-4",
"messages": [
{
"role": "user",
"content": "Hallo, bitte stelle EXAMPLE vor"
}
],
"temperature": 0.7,
"max_tokens": 1000
}
Dies ist ein typischer Request-Body einer KI-API.
Einige Kernregeln:
-
Für Objekte verwenden Sie
{ }zum Umschließen, für Arrays verwenden Sie[ ]zum Umschließen. -
Strings verwenden doppelte Anführungszeichen
", einfache Anführungszeichen sind nicht erlaubt. -
Schlüssel-Wert-Paare verwenden einen Doppelpunkt
:zum Trennen, Schlüssel müssen Strings sein. -
Mehrere Schlüssel-Wert-Paare verwenden ein Komma
,zum Trennen.
JSON sieht Python-Dictionaries sehr ähnlich, aber es gibt syntaktische Unterschiede; achten Sie beim Schreiben von Code darauf.
Einrichtung der Entwicklungsumgebung
Um gute Arbeit zu leisten, muss man zuerst sein Werkzeug schärfen.
Python-Installation und -Konfiguration
Python ist die am häufigsten verwendete Sprache zum Aufrufen von KI-APIs, mit einem ausgereiften Ökosystem und reichhaltigen Bibliotheken.
Prüfen Sie zunächst, ob Python auf Ihrem Computer installiert ist:
# 检查 Python 版本(Windows、macOS、Linux 通用) python --version # 或者 python3 --version
Es wird empfohlen, Python 3.9 oder höher zu verwenden.
Wenn nicht installiert, gehen Sie zupython.orgund laden Sie die neueste stabile Version herunter.
pip-Paketverwaltung
pip ist der Paketmanager von Python und wird zur Installation von Drittanbieter-Bibliotheken verwendet.
# 检查 pip 版本 pip --version # 或者 pip3 --version # 升级 pip 到最新版本 pip install --upgrade pip # 配置国内镜像源(可选,提升下载速度) pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
Auswahl des Code-Editors
Für das Schreiben von KI-API-Code empfehlen wir einen der folgenden Editoren:
| Editor | Funktionen | Zielbenutzer |
|---|---|---|
| VS Code | Kostenlos, reichhaltiges Plugin-Ökosystem, leichtgewichtig | Die meisten Entwickler |
| Cursor | Integrierte KI-Unterstützung, kann direkt Code generieren | Für diejenigen, die KI beim Schreiben von Code nutzen möchten |
| PyCharm | Funktionsreichste, beste Python-Unterstützung | Professionelle Python-Entwickler |
Der Beispielcode in diesem Tutorial kann in jedem Editor ausgeführt werden.
Grundlagen der OpenAI-API
Die OpenAI-API ist die klassischste und am besten etablierte KI-API, und viele andere Anbieter sind mit ihrem Format kompatibel.
Registrierung und Abrufen des API-Schlüssels
Der API-Schlüssel ist Ihr Ausweis, er bestätigt Ihre Identität und zeichnet Ihre Nutzung auf. Schritte zum Erhalt:
-
1. Besuchen Sieplatform.openai.comRegistrieren Sie ein Konto
-
2. Gehen Sie zur Seite API Keys
-
3. Klicken Sie auf "Create new secret key"
-
4. Kopieren und speichern Sie diesen Schlüssel (er wird nur einmal angezeigt!)
Wichtig:Committen Sie Ihren API-Schlüssel niemals in ein öffentliches Code-Repository. Wenn er einmal geleakt ist, können andere Ihr Kontingent nutzen und Kosten verursachen.
Erster API-Aufruf
Installieren Sie zuerst das offizielle OpenAI-SDK:
pip install openai
Schreiben Sie nun Ihr erstes API-Aufrufprogramm:
Beispiele
# Erstes Beispiel für einen OpenAI-API-Aufruf
from openai import OpenAI
# Client initialisieren
# Hinweis: Es wird empfohlen, den API-Schlüssel aus Umgebungsvariablen zu lesen; hardcodieren Sie ihn nicht im Code
# Zu Demonstrationszwecken wird er hier direkt geschrieben. In echten Projekten verwenden Sie Umgebungsvariablen.
client = OpenAI(
api_key="your-api-key-here" # Ersetzen Sie dies durch Ihren API-Schlüssel
)
# Chat-Anfrage senden
response = client.chat.completions.create(
model="gpt-3.5-turbo", # Modell auswählen
messages=[
{
"role": "user", # Rolle: user steht für den Benutzer
"content": "Bitte stellen Sie EXAMPLEs Rookie Tutorial in einem Satz vor." # Vom Benutzer eingegebener Inhalt
}
]
)
# Vollständige Antwort ausgeben (sehen, was zurückgegeben wurde)
print("Vollständige Antwort:")
print(response)
print("\n" + "="*50 + "\n")
# Die Antwort der KI extrahieren
ai_reply = response.choices[0].message.content
print("KI-Antwort:")
print(ai_reply)
Wenn Sie keinen OpenAI api_key haben, können Sie auch inländische Alternativen verwenden. Viele inländische Modelle sind mit OpenAI kompatibel, wie DeepSeek. Sie können zuhttps://platform.deepseek.com/api_keysbeantragen Sie einen api_key und ersetzen Sie dann Ihre durch den folgenden Code:api_keyundmodel, DeepSeek unterstützt die Modelle deepseek-v4-flash und deepseek-v4-pro (Denkmodus), und Sie können die API verwenden, um große Modelle aufzurufen:
Beispiele
# Client initialisieren
# Hinweis: Es wird empfohlen, den API-Schlüssel aus einer Umgebungsvariable zu lesen, hardcodieren Sie ihn nicht im Code
# Zu Demonstrationszwecken wird er hier direkt geschrieben. In tatsächlichen Projekten verwenden Sie bitte Umgebungsvariablen
client = OpenAI(
api_key="sk-xxxx", # api_key festlegen
base_url="https://api.deepseek.com") # Anfrageadresse festlegen
# Chat-Anfrage senden
response = client.chat.completions.create(
model="deepseek-v4-flash", # Modell auswählen
messages=[
{
"role": "user", # Rolle: user steht für den Benutzer
"content": "Bitte stellen Sie EXAMPLEs Rookie Tutorial in einem Satz vor." # Vom Benutzer eingegebener Inhalt
}
]
)
# Vollständige Antwort ausgeben (sehen, was zurückgegeben wurde)
print("Vollständige Antwort:")
print(response)
print("\n" + "="*50 + "\n")
# Die Antwort der KI extrahieren
ai_reply = response.choices[0].message.content
print("KI-Antwort:")
print(ai_reply)
Führen Sie dieses Programm aus:
python first_api_call.py
Wenn alles normal funktioniert, sehen Sie eine Ausgabe ähnlich wie diese:
完整响应: ChatCompletion( id='chatcmpl-xxx', choices=[Choice(finish_reason='stop', index=0, message=ChatMessage(content='Example是一个专注于提供编程技术教程的学习平台...', role='assistant'))], model='gpt-3.5-turbo', usage=CompletionUsage(completion_tokens=30, prompt_tokens=18, total_tokens=48) ) ================================================== AI 回复: Example是一个专注于提供编程技术教程的学习平台,涵盖多种编程语言和技术领域。
Herzlichen Glückwunsch! Sie haben erfolgreich eine KI-API aufgerufen.
Erklärung der Anfrageparameter
Die OpenAI-API hat viele Parameter, die angepasst werden können. Hier sind die am häufigsten verwendeten:
| Parametername | Type | Erforderlich | Beschreibung | Standardwert |
|---|---|---|---|---|
| model | string | Ja | Die zu verwendende Modell-ID, wie gpt-3.5-turbo, gpt-4 | Keine |
| messages | array | Ja | Liste der Nachrichten des Konversationsverlaufs | Keine |
| temperature | number | nein | Sampling-Temperatur, zwischen 0-2. Je höher, desto zufälliger; je niedriger, desto deterministischer. | 1.0 |
| max_tokens | integer | nein | Maximale Anzahl der zu generierenden Tokens | Unbegrenzt |
| top_p | number | nein | Nucleus-Sampling-Parameter, zwischen 0-1 | 1.0 |
| stop | string/array | nein | Stoppsequenz; Generierung stoppen, wenn diese Zeichen auftreten | null |
Konzentrieren wir uns auf temperature, den am häufigsten verwendeten Anpassungsparameter:
Beispiele
# Demonstrieren Sie die Auswirkung des temperature-Parameters auf die Ausgabe
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
def ask_ai(temperature_value: float, question: str) -> str:
"""Geben Sie die Temperatur für die Frage an"""
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": question}],
temperature=temperature_value,
max_tokens=200
)
return response.choices[0].message.content
# Stellen Sie die gleiche Frage dreimal mit unterschiedlicher Temperatur
question = "Gib EXAMPLE einen Slogan"
print("--- temperature=0 (am deterministischsten, Ergebnisse sind jedes Mal ähnlich) ---")
print(ask_ai(0.0, question))
print("\n--- temperature=0.7 (ausgewogen, für den täglichen Gebrauch empfohlen) ---")
print(ask_ai(0.7, question))
print("\n--- temperature=1.8 (am zufälligsten, Ergebnisse variieren jedes Mal stark) ---")
print(ask_ai(1.8, question))
Eine Faustregel:
-
temperature=0: faktische Antworten, Codegenerierung, Szenarien, die präzise Ergebnisse erfordern
-
temperature=0.7: alltägliche Konversation, allgemeine Aufgaben
-
temperature>1.0: kreatives Schreiben, Brainstorming
Anthropic Claude API
Claude ist Anthropics großes Sprachmodell, bekannt für seine Sicherheit und Fähigkeiten zur Verarbeitung langer Texte.
Gemeinsamkeiten und Unterschiede zur OpenAI API
Beide können Textgenerierung, aber es gibt einige Unterschiede in der Designphilosophie:
| Vergleichspunkt | OpenAI API | Claude API |
|---|---|---|
| Nachrichtenstruktur | system, user, assistant wechseln sich ab | system wird separat festgelegt, user und assistant wechseln sich ab |
| Kontextlänge | 16k-128k variiert | Claude 3 Serie unterstützt 200k |
| Parameterdesign | temperature, top_p, usw. | temperature, top_p, usw., ähnliche Konzepte |
Struktur der Claude Messages API
Installieren Sie zuerst das Claude SDK:
pip install anthropic
Grundlegende Aufrufe der Claude API:
Beispiele
# Einfaches Beispiel für einen Claude-API-Aufruf
import anthropic
# Client initialisieren
client = anthropic.Anthropic(
api_key="your-api-key-here" # Durch Ihren Claude API Key ersetzen
)
# Nachrichten-Anfrage senden
response = client.messages.create(
model="claude-3-sonnet-20240229", # Claude-Modell auswählen
max_tokens=1024, # Bei Claude muss max_tokens festgelegt werden
messages=[
{
"role": "user",
"content": "Bitte stellen Sie EXAMPLE Rookie Tutorial in drei Sätzen vor"
}
]
)
# Antwort ausgeben
print("Vollständige Antwort:")
print(response)
print("\n" + "="*50 + "\n")
# Antwort extrahieren
print("Claudes Antwort:")
print(response.content[0].text)
Ähnlich können wir es durch ein kompatibles inländisches großes Modell ersetzen, z. B. DeepSeek, wobei wirapi_key 、 base_url、modeldiese drei Parameter angeben:
Beispiele
# Client initialisieren
client = anthropic.Anthropic(
api_key="sk-xxx", # Durch Ihren API Key ersetzen
base_url="https://api.deepseek.com/anthropic" # Basis-URL für Claude API
)
# Nachrichten-Anfrage senden
response = client.messages.create(
model="deepseek-v4-flash", # Claude-Modell auswählen
max_tokens=1024, # Bei Claude muss max_tokens festgelegt werden
messages=[
{
"role": "user",
"content": "Bitte stellen Sie das EXAMPLE-Tutorial in drei Sätzen vor."
}
]
)
# Antwort ausgeben
print("Vollständige Antwort:")
print(response)
print("\n" + "="*50 + "\n")
# Antwort extrahieren
print("Claude-Antwort:")
print(response.content[0].thinking)
System-Prompt-Einstellungen
Bei der Claude API ist System Prompt ein unabhängiger Parameter und wird nicht im messages-Array platziert:
Beispiele
# Verwendungsbeispiel für Claude-System-Prompt
import anthropic
client = anthropic.Anthropic(api_key="your-api-key-here")
response = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1024,
# System-Prompt wird hier festgelegt
system="Du bist ein professioneller Redakteur für technische Dokumentation. Halte Antworten präzise und genau und verwende Listen, wo es angebracht ist.",
messages=[
{
"role": "user",
"content": "Welche Kernkenntnisse sollten beim Erlernen von Python beherrscht werden?"
}
]
)
print(response.content[0].text)
Mehrrunden-Konversationsverwaltung
Einzelrunden-Konversationen sind einfach, aber wirklich nützliche Anwendungen müssen sich "den Kontext merken."
Möglichkeiten zum Führen des Konversationsverlaufs
Der Ansatz ist einfach:Alle vorherigen Konversationen speichern und sie bei jeder Anfrage an die KI senden。
Beispiele
# Beispiel für Mehrrunden-Konversationsverwaltung
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
class ChatBot:
"""Ein einfacher Mehrrunden-Konversationsbot"""
def __init__(self, system_prompt: str = "Du bist ein hilfreicher Assistent"):
self.messages = [] # Eine Liste verwenden, um den Konversationsverlauf zu speichern
# Zuerst den System-Prompt hinzufügen
self.messages.append({
"role": "system",
"content": system_prompt
})
def chat(self, user_input: str) -> str:
"""Eine Nachricht senden und eine Antwort erhalten"""
# Benutzernachricht zum Verlauf hinzufügen
self.messages.append({
"role": "user",
"content": user_input
})
# API aufrufen
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=self.messages
)
# KI-Antwort abrufen
ai_reply = response.choices[0].message.content
# Auch die KI-Antwort zum Verlauf hinzufügen
self.messages.append({
"role": "assistant",
"content": ai_reply
})
return ai_reply
def get_history(self) -> list:
"""Konversationsverlauf abrufen"""
return self.messages
# Verwendungsbeispiel
if __name__ == "__main__":
bot = ChatBot(system_prompt="Du bist ein Programmierassistent, der sich darauf spezialisiert hat, Fragen zu EXAMPLE und Python zu beantworten")
print("=== Demo für Mehrrunden-Konversation ===")
# Erste Runde
r1 = bot.chat("Was ist Python?")
print(Benutzer: Was ist Python?)
print("KI:", r1)
print()
# Zweite Runde (KI kann sich an das vorherige Thema erinnern)
r2 = bot.chat(Welche Funktionen hat es?)
print(Benutzer: Welche Funktionen hat es?)
print("KI:", r2)
print()
# Dritte Runde
r3 = bot.chat(Gibt es Python-Tutorials auf EXAMPLE?)
print(Benutzer: Gibt es Python-Tutorials auf EXAMPLE?)
print("KI:", r3)
Wichtiger Punkt: Der Konversationsverlauf ist eine geordnete Liste, die streng zwischen Benutzer-Assistent-Benutzer-Assistent wechselt. Jede Anfrage muss den vollständigen Verlauf senden, damit die KI den Kontext verstehen kann. Verlauf verbraucht Tokens und muss daher regelmäßig bereinigt werden.
Umgang mit Kontextfenster-Überlauf
Jedes Modell hat ein Kontextfensterlimit, z. B. hat gpt-3.5-turbo 16k, gpt-4 8k oder 32k.
Wenn der Konversationsverlauf zu lang ist, wird ein Fehler ausgelöst.
Mehrere gängige Umgangsstrategien:
Beispiele
# Beispiel für Strategien zur Kontextfensterverwaltung
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
class ChatBotWithContextLimit:
"""Chatbot mit Kontextlimit"""
def __init__(self, system_prompt: str, max_messages: int = 10):
self.system_prompt = system_prompt
self.max_messages = max_messages # Wie viele Nachrichten maximal behalten werden
self.messages = []
def _trim_messages(self):
"""Nachrichtenliste kürzen, die neuesten Nachrichten behalten"""
# Immer den System-Prompt behalten, dann nur die neuesten max_messages behalten
if len(self.messages) > self.max_messages:
# Die neuesten N Nachrichten behalten
self.messages = self.messages[-self.max_messages:]
def chat(self, user_input: str) -> str:
# Benutzernachricht hinzufügen
self.messages.append({
"role": "user",
"content": user_input
})
# Verlauf kürzen
self._trim_messages()
# Vollständige Anfrage erstellen (System-Prompt + Verlauf)
full_messages = [
{"role": "system", "content": self.system_prompt}
] + self.messages
try:
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=full_messages
)
ai_reply = response.choices[0].message.content
self.messages.append({
"role": "assistant",
"content": ai_reply
})
return ai_reply
except Exception as e:
# Wenn weiterhin Fehler auftreten, ist möglicherweise aggressiveres Kürzen erforderlich
return f"Fehler: {str(e)}"
# Strategie 2: KI verwenden, um den Gesprächsverlauf zusammenzufassen
def summarize_conversation(messages: list) -> str:
"""KI verwenden, um den Konversationsverlauf zusammenzufassen und den ursprünglichen Verlauf zu ersetzen"""
history_text = "\n".join([
f"{m['role']}: {m['content']}"
for m in messages
])
prompt = f"""Bitte fasse die folgende Konversation in einer prägnanten Zusammenfassung zusammen und bewahre dabei wichtige Informationen:
{history_text}
Zusammenfassung: """
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
temperature=0
)
return response.choices[0].message.content
# Zusammenfassungsstrategie verwenden
print("--- Beispiel für eine Zusammenfassung des Konversationsverlaufs ---")
sample_history = [
{"role": "user", "content": "Wie heiße ich?"},
{"role": "assistant", "content": "Entschuldigung, ich kenne deinen Namen nicht. Du kannst ihn mir sagen."},
{"role": "user", "content": "Mein Name ist Xiao Ming, ich lerne Python bei EXAMPLE."},
{"role": "assistant", "content": "Hallo Xiao Ming! Freut mich, dich kennenzulernen. EXAMPLE ist eine großartige Lernplattform."},
{"role": "user", "content": "Ich möchte etwas über Listen lernen, kannst du es mir beibringen?"},
{"role": "assistant", "content": "Natürlich! Python-Listen sind..."},
]
summary = summarize_conversation(sample_history)
print("Zusammenfassung der Konversation:", summary)
Fasse die Methoden der Kontextverwaltung zusammen:
| Strategie | Vorteile | Nachteile | Anwendbare Szenarien |
|---|---|---|---|
| Nur die neuesten N Einträge behalten | Einfach, schnell | Kann wichtige Informationen verlieren | Kurze Konversationen, lockere Chat-Szenarien |
| KI verwenden, um den Verlauf zusammenzufassen | Bewahrt semantische Informationen | Erfordert zusätzliche API-Aufrufe | Lange Konversationen, viele wichtige Informationen |
| Gleitendes Fenster | Balanciert Einfachheit und Vollständigkeit | Etwas komplexer zu implementieren | Allgemeiner Zweck für gängige Szenarien |
Streaming-Ausgabe
Wenn man auf einer Webseite mit KI chattet, sieht man den Text Wort für Wort erscheinen — das ist Streaming-Ausgabe.
Was ist Streaming-Ausgabe
-
Normaler Modus: Die KI gibt die vollständige Antwort erst nach der Generierung auf einmal zurück; möglicherweise muss man mehrere Sekunden oder sogar Dutzende Sekunden warten.
-
Streaming-Modus: Die KI sendet jedes Token, sobald es generiert wurde, was für eine bessere Benutzererfahrung sorgt.
Technisch gesehen verwendet die Streaming-Ausgabe das SSE-Protokoll (Server-Sent Events), bei dem der Server kontinuierlich Daten pusht.
Implementierung des Schreibmaschineneffekts
Beispiele
# Demo der Streaming-Ausgabe (Schreibmaschineneffekt)
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
print("=== Demo der Streaming-Ausgabe ===")
print("F: Bitte schreibe eine Einführung zu EXAMPLE\n")
print("A:", end="", flush=True)
# Schlüsselparameter: stream=True
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": "Bitte schreibe eine Einführung in das EXAMPLE-Tutorial"}
],
stream=True # Streaming-Ausgabe aktivieren
)
collected_reply = []
for chunk in response:
# Den Inhalt des aktuellen Chunks extrahieren
if chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end="", flush=True) # In Echtzeit ohne Zeilenumbrüche ausgeben
collected_reply.append(content)
print() # Am Ende einen Zeilenumbruch ausgeben
print("\n" + "="*50)
print("Vollständige Antwort:", "".join(collected_reply))
Führen Sie dieses Programm aus, und Sie werden sehen, wie der Text Wort für Wort erscheint.
Die Verwendung der Streaming-Ausgabe von Claude ist ähnlich:
Beispiele
# Beispiel für Claude-Streaming-Ausgabe
import anthropic
client = anthropic.Anthropic(api_key="your-api-key-here")
print("=== Claude-Streaming-Ausgabe ===")
print("Frage: Wie lernt man programmieren?\n")
print("A:", end="", flush=True)
with client.messages.stream(
model="claude-3-sonnet-20240229",
max_tokens=1024,
messages=[{"role": "user", "content": "Wie lernt man systematisch programmieren?"}]
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
print()
Ratschlag zur Benutzererfahrung: Solange das Szenario nicht "auf das vollständige Ergebnis warten" erfordert, priorisieren Sie die Streaming-Ausgabe. Wenn Benutzer den Fortschritt sehen, kann dies die Erfahrung erheblich verbessern.
API-Kostenberechnung und -optimierung
KI-APIs werden nutzungsbasiert abgerechnet; je mehr Sie nutzen, desto mehr zahlen Sie.
Prinzipien der Token-Abrechnung
Die KI-API wird nicht nach Wortanzahl oder Anzahl der Unterhaltungen abgerechnet, sondern durchToken,. Tokenist die grundlegende Einheit der KI-Textverarbeitung.
Ein Token entspricht ungefähr:
Englisch: 0.75 Wörter (oder 4 Buchstaben)
-
Chinesisch: 1-2 chinesische Schriftzeichen
Zum Beispiel:
-
"Hallo, Welt" — ungefähr 3-4 Token
-
"BEISPIEL Rookie Tutorial ist großartig" — ungefähr 6-8 Token
Abrechnungsmethode:
Prompt tokens(你发给 AI 的) + Completion tokens(AI 返回给你的)= 总 tokens
Verschiedene Modelle haben unterschiedliche Preise; zum Beispiel kostet gpt-3.5-turbo $0.0015/1k Prompt-Token, $0.002/1k Completion-Token.
Wie man API-Kosten kontrolliert
Beispiele
# Beispiel zur Verfolgung und Kontrolle von API-Kosten
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
# Modell-Preisliste (Beispiel, tatsächliche Preise bitte in der offiziellen Dokumentation prüfen)
# Einheit: USD / 1k Token
MODEL_PRICES = {
"gpt-3.5-turbo": {
"prompt": 0.0015,
"completion": 0.002
},
"gpt-4": {
"prompt": 0.03,
"completion": 0.06
}
}
def chat_with_cost_tracking(model: str, messages: list):
"""Chat mit Kostenstatistik"""
response = client.chat.completions.create(
model=model,
messages=messages
)
# Token-Nutzung aus der Antwort abrufen
usage = response.usage
prompt_tokens = usage.prompt_tokens
completion_tokens = usage.completion_tokens
total_tokens = usage.total_tokens
# Kosten berechnen
price = MODEL_PRICES.get(model, {"prompt": 0, "completion": 0})
prompt_cost = (prompt_tokens / 1000) * price["prompt"]
completion_cost = (completion_tokens / 1000) * price["completion"]
total_cost = prompt_cost + completion_cost
return {
"reply": response.choices[0].message.content,
"usage": {
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"total_tokens": total_tokens
},
"cost": {
"prompt_cost": prompt_cost,
"completion_cost": completion_cost,
"total_cost": total_cost
}
}
# Verwendungsbeispiel
if __name__ == "__main__":
result = chat_with_cost_tracking(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Python vorstellen"}]
)
print("KI-Antwort:", result["reply"])
print()
print("Nutzungsstatistiken:")
print(f" Prompt-Tokens: {result['usage']['prompt_tokens']}")
print(f" Completion-Tokens: {result['usage']['completion_tokens']}")
print(f" Gesamt-Tokens: {result['usage']['total_tokens']}")
print()
print("Kostenstatistik (USD):")
print(f" Prompt-Kosten: ${result['cost']['prompt_cost']:.6f}")
print(f" Completion-Kosten: ${result['cost']['completion_cost']:.6f}")
print(f" Gesamtkosten: ${result['cost']['total_cost']:.6f}")
Einige praktische Tipps zur Kostenoptimierung:
| Tipp | Wie man es umsetzt | Einsparquote |
|---|---|---|
| Wählen Sie das richtige Modell | Verwenden Sie gpt-3.5-turbo für einfache Aufgaben, nicht gpt-4 | 90%+ |
| max_tokens begrenzen | Legen Sie eine vernünftige Obergrenze fest, damit die KI nicht zu viel sagt | Kommt auf die Situation an |
| Kontext kürzen | Nur den notwendigen Gesprächsverlauf behalten | 50%+ |
| Prompts knapp halten | Machen Sie den System-Prompt nicht zu lang | Kommt auf die Situation an |
| Ergebnis-Caching | Für identische Fragen direkt zwischengespeicherte Ergebnisse zurückgeben | Kommt auf die Situation an |
Caching-Strategien
Bei wiederholten Fragen kann das Zwischenspeichern von Ergebnissen viel Geld sparen:
Beispiele
# Einfache Implementierung eines Antwort-Caches
import hashlib
import json
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
class SimpleCache:
"""Einfacher In-Memory-Cache"""
def __init__(self):
self.cache = {}
def _make_key(self, model: str, messages: list) -> str:
"""Cache-Schlüssel basierend auf Anfrageinhalt generieren"""
# Schlüsselinformationen serialisieren und einen Hash berechnen
key_data = {
"model": model,
"messages": messages
}
key_str = json.dumps(key_data, sort_keys=True)
return hashlib.md5(key_str.encode()).hexdigest()
def get(self, model: str, messages: Liste):
"""Cache abrufen"""
key = self._make_key(model, messages)
return self.cache.get(key)
def set(self, model: str, messages: list, value: str):
"""Cache setzen"""
key = self._make_key(model, messages)
self.cache[key] = value
# Chat-Funktion mit Cache
cache = SimpleCache()
def chat_with_cache(model: str, messages: list):
# Zuerst Cache prüfen
cached = cache.get(model, messages)
if cached:
print("(Cache-Treffer, direkt zurückgeben)")
return cached
# Kein Cache-Treffer, API aufrufen
response = client.chat.completions.create(
model=model,
messages=messages
)
reply = response.choices[0].message.content
# Im Cache speichern
cache.set(model, messages, reply)
return reply
# Test
if __name__ == "__main__":
messages = [{"role": "user", "content": "Was für eine Website ist EXAMPLE?"}]
print("Erster Aufruf...")
r1 = chat_with_cache("gpt-3.5-turbo", messages)
print(r1)
print()
print("Zweiter Aufruf (gleiche Frage)...")
r2 = chat_with_cache("gpt-3.5-turbo", messages)
print(r2)
Fehlerbehandlung und Wiederholungsmechanismen
Netzwerkanfragen können immer fehlschlagen, und APIs sind keine Ausnahme. Robuster Code muss verschiedene Ausnahmeszenarien behandeln.
Häufige Fehlertypen
| Fehlertyp | HTTP-Statuscode | Ursache | Behandlungsmethode |
|---|---|---|---|
| Authentifizierungsfehler | 401 | API-Schlüssel falsch oder abgelaufen | API-Schlüssel prüfen |
| Unzureichendes Kontingent | 402 | Konto hat kein Guthaben | Aufladen oder Konto wechseln |
| Limit überschritten | 429 | Anfrage zu schnell oder Kontingent erschöpft | Eine Weile warten und erneut versuchen |
| Serverfehler | 5xx | Problem auf KI-Serverseite | Wiederholen |
Exponentielle Backoff-Wiederholung
Bei vorübergehenden Fehlern (wie 429, 5xx) ist die gebräuchlichste Strategie die exponentielle Backoff-Wiederholung:
-
Erster Fehlschlag → 1 Sekunde warten → erneut versuchen
-
Zweiter Fehlschlag → 2 Sekunden warten → erneut versuchen
-
Dritter Fehlschlag → 4 Sekunden warten → erneut versuchen
-
Vierter Fehlschlag → 8 Sekunden warten → erneut versuchen
Jede Wartezeit verdoppelt sich, wodurch der Dienst eine Chance zur Erholung erhält.
Beispiele
# Fehlerbehandlung und exponentielle Backoff-Wiederholung
import time
from openai import OpenAI, APIError, RateLimitError, APIConnectionError
client = OpenAI(api_key="your-api-key-here")
def chat_with_retry(
model: str,
messages: list,
max_retries: int = 3,
initial_wait: float = 1.0
):
"""Chat-Funktion mit Wiederholungsmechanismus"""
retries = 0
while retries <= max_retries:
try:
response = client.chat.completions.create(
model=model,
messages=messages
)
return {
"success": True,
"reply": response.choices[0].message.content
}
except RateLimitError as e:
# Rate-Limit-Fehler: eine Weile warten und erneut versuchen
retries += 1
if retries > max_retries:
return {
"success": False,
"error": f"Wiederholungsversuche erschöpft: {str(e)}"
}
wait_time = initial_wait * (2 ** (retries - 1))
print(f"Rate-Limit ausgelöst, warte {wait_time} Sekunden vor erneutem Versuch...")
time.sleep(wait_time)
except APIConnectionError as e:
# Netzwerkverbindungsfehler: erneut versuchen
retries += 1
if retries > max_retries:
return {
"success": False,
"error": f"Netzwerkverbindung fehlgeschlagen: {str(e)}"
}
wait_time = initial_wait * (2 ** (retries - 1))
print(f"Netzwerkfehler, warte {wait_time} Sekunden vor erneutem Versuch...")
time.sleep(wait_time)
except APIError as e:
# API-Fehler: je nach Situation erneut versuchen
if e.status_code and 500 <= e.status_code < 600:
retries += 1
if retries > max_retries:
return {
"success": False,
"error": f"Serverfehler: {str(e)}"
}
wait_time = initial_wait * (2 ** (retries - 1))
print(f"Serverfehler, warte {wait_time} Sekunden vor erneutem Versuch...")
time.sleep(wait_time)
else:
# Nicht-5xx-Fehler, nicht erneut versuchen
return {
"success": False,
"error": fAPI-Fehler: {str(e)}
}
except Exception as e:
# Andere Fehler, nicht wiederholen
return {
"success": False,
"error": fUnbekannter Fehler: {str(e)}
}
# Verwendungsbeispiel
if __name__ == "__main__":
result = chat_with_retry(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Hallo, EXAMPLE"}]
)
if result["success"]:
print(Erfolg:, result["reply"])
else:
print(Fehler:, result["error"])
Sie können auch eine vorhandene Bibliothek wie tenacity verwenden, um die Wiederholungslogik zu vereinfachen. Installieren Sie sie mit dem folgenden Befehl:
pip install tenacity
Beispiele
# Verwenden Sie die tenacity-Bibliothek, um die Wiederholungslogik zu vereinfachen
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
from openai import OpenAI, RateLimitError, APIError
client = OpenAI(api_key="your-api-key-here")
@retry(
stop=stop_after_attempt(3), # Bis zu 3-mal wiederholen
wait=wait_exponential(multiplier=1, min=1, max=10), # Exponentielles Backoff: 1, 2, 4... bis zu 10 Sekunden
retry=retry_if_exception_type((RateLimitError, APIError)) # Nur bei bestimmten Ausnahmen wiederholen
)
def chat_with_tenacity(model: str, messages: list):
"""Tenacity-Decorator verwenden, um Wiederholung zu implementieren"""
response = client.chat.completions.create(
model=model,
messages=messages
)
return response.choices[0].message.content
# Verwendung
try:
reply = chat_with_tenacity(
"gpt-3.5-turbo",
[{"role": "user", "content": "Stelle Python vor"}]
)
print(reply)
except Exception as e:
print(fEndgültiger Fehler: {e})
Praxisprojekt: KI-Chat-Tool für die Kommandozeile
Jetzt integrieren wir, was wir zuvor gelernt haben, und erstellen ein vollständiges Kommandozeilen-Chat-Tool.
Beispiele
# EXAMPLE KI-Chatbot - Vollständiges Kommandozeilen-Tool
import sys
import json
import os
from datetime import datetime
from openai import OpenAI
class ExampleChatBot:
"""Ein voll funktionsfähiger Kommandozeilen-Chatbot"""
def __init__(self, config_file: str = "config.json"):
# Konfiguration laden
self.config = self._load_config(config_file)
self.client = OpenAI(api_key=self.config["api_key"])
# Gesprächszustand
self.messages = []
self.total_tokens = 0
self.total_cost = 0.0
# System-Prompt initialisieren
self._init_system_prompt()
def _load_config(self, config_file: str) -> dict:
"""Konfigurationsdatei laden"""
default_config = {
"api_key": "your-api-key-here",
"model": "gpt-3.5-turbo",
"system_prompt": "Du bist ein hilfreicher KI-Assistent, bereitgestellt von EXAMPLE.",
"max_history": 20,
"stream": True,
"temperature": 0.7
}
if os.path.exists(config_file):
with open(config_file, "r", encoding="utf-8") as f:
user_config = json.load(f)
default_config.update(user_config)
return default_config
def _save_config(self, config_file: str = "config.json"):
"""Konfigurationsdatei speichern"""
with open(config_file, "w", encoding="utf-8") as f:
json.dump(self.config, f, indent=2, ensure_ascii=False)
def _init_system_prompt(self):
"""System-Prompt initialisieren"""
self.messages = [
{
"role": "system",
"content": self.config["system_prompt"]
}
]
def _trim_history(self):
"""Gesprächsverlauf kürzen"""
# System-Prompt + die letzten N Gespräche behalten
max_messages = self.config["max_history"]
if len(self.messages) > max_messages + 1:
self.messages = [self.messages[0]] + self.messages[-max_messages:]
def chat(self, user_input: str) -> str:
"""Nachricht senden und Antwort erhalten"""
# Benutzernachricht hinzufügen
self.messages.append({
"role": "user",
"content": user_input
})
# Verlauf kürzen
self._trim_history()
if self.config["stream"]:
return self._chat_stream()
else:
return self._chat_normal()
def _chat_normal(self) -> str:
"""Normaler Modus (nicht streamend)"""
response = self.client.chat.completions.create(
model=self.config["model"],
messages=self.messages,
temperature=self.config["temperature"]
)
ai_reply = response.choices[0].message.content
# Verbrauch zählen
if hasattr(response, "usage"):
self.total_tokens += response.usage.total_tokens
# Kosten grob schätzen (gpt-3.5-turbo-Preis)
self.total_cost += (response.usage.total_tokens / 1000) * 0.002
self.messages.append({
"role": "assistant",
"content": ai_reply
})
return ai_reply
def _chat_stream(self) -> str:
"""Streaming-Modus"""
response = self.client.chat.completions.create(
model=self.config["model"],
messages=self.messages,
temperature=self.config["temperature"],
stream=True
)
collected_chunks = []
print("KI:", end="", flush=True)
for chunk in response:
if chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end="", flush=True)
collected_chunks.append(content)
print()
ai_reply = "".join(collected_chunks)
self.messages.append({
"role": "assistant",
"content": ai_reply
})
# Die Token-Zählung im Streaming-Modus erfordert zusätzliche Behandlung, hier vereinfacht
# In realen Projekten kann man die Usage-API aufrufen oder schätzen
self.total_tokens += len(ai_reply) // 2 # Grobe Schätzung
return ai_reply
def save_conversation(self, filename: str = None):
"""Konversationsverlauf speichern"""
if not filename:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"conversation_{timestamp}.json"
data = {
"model": self.config["model"],
"total_tokens": self.total_tokens,
"estimated_cost": self.total_cost,
"messages": self.messages,
"saved_at": datetime.now().isoformat()
}
with open(filename, "w", encoding="utf-8") as f:
json.dump(data, f, indent=2, ensure_ascii=False)
return filename
def clear_history(self):
"""Gesprächsverlauf löschen"""
self._init_system_prompt()
self.total_tokens = 0
self.total_cost = 0.0
def show_stats(self):
"""Statistiken anzeigen"""
print("\n" + "="*40)
print(Konversationsstatistiken)
print("="*40)
print(fModell: {self.config['model']})
print(fNachrichtenanzahl: {len(self.messages) - 1})
print(fToken insgesamt: {self.total_tokens})
print(fGeschätzte Kosten: ${self.total_cost:.4f})
print("="*40 + "\n")
def print_help():
"""Hilfeinformationen ausgeben"""
print("\n" + "="*40)
print(BEISPIEL KI-Chat-Tool - Befehlsliste)
print("="*40)
print(/help - Hilfe anzeigen)
print(/clear - Konversationsverlauf löschen)
print(/stats - Statistiken anzeigen)
print(/save - Konversationsverlauf speichern)
print(/model - Modell wechseln)
print(/temp - Temperatur anpassen)
print(/system - System-Prompt ändern)
print(/quit - Programm beenden)
print("="*40 + "\n")
def main():
print("="*40)
print(BEISPIEL KI-Chat-Tool)
print("="*40)
print(Geben Sie /help ein, um Befehle anzuzeigen, oder geben Sie Text direkt ein, um mit dem Chatten zu beginnen\n")
bot = ExampleChatBot()
while True:
try:
user_input = input(Du:).strip()
if not user_input:
continue
# Befehle verarbeiten
if user_input.startswith("/"):
cmd = user_input.lower()
if cmd in ["/quit", "/exit", "/q"]:
print(Auf Wiedersehen!)
break
elif cmd == "/help":
print_help()
elif cmd == "/clear":
bot.clear_history()
print(Konversationsverlauf gelöscht)
elif cmd == "/stats":
bot.show_stats()
elif cmd == "/save":
filename = bot.save_conversation()
print(fKonversation gespeichert unter: {filename})
elif cmd.startswith("/model "):
model = user_input[7:].strip()
bot.config["model"] = model
bot._save_config()
print(fModell gewechselt zu: {model})
elif cmd.startswith("/temp "):
try:
temp = float(user_input[6:].strip())
if 0 <= temp <= 2:
bot.config["temperature"] = temp
bot._save_config()
print(fTemperatur eingestellt auf: {temp})
else:
print(Temperatur muss zwischen 0-2 liegen)
except ValueError:
print(Bitte gib eine gültige Zahl ein)
elif cmd.startswith("/system "):
system_prompt = user_input[8:].strip()
bot.config["system_prompt"] = system_prompt
bot.clear_history()
bot._save_config()
print(System-Prompt aktualisiert, Konversation zurückgesetzt)
else:
print(Unbekannter Befehl, gib /help für Hilfe ein)
else:
# Normaler Chat
if not bot.config["stream"]:
print("KI:", end="")
bot.chat(user_input)
print()
except KeyboardInterrupt:
print("\nGib /quit ein, um zu beenden, oder chatte weiter)
except Exception as e:
print(fFehler: {e})
if __name__ == "__main__":
main()
Erstelle eine Konfigurationsdatei:
{
"api_key": "your-api-key-here",
"model": "gpt-3.5-turbo",
"system_prompt": "你是一个乐于助人的 AI 助手,由 EXAMPLE 提供技术支持。",
"max_history": 20,
"stream": true,
"temperature": 0.7
}
Jetzt kannst du dieses Chat-Tool ausführen:
python example_chatbot.py
Du wirst sehen:
======================================== EXAMPLE AI 聊天工具 ======================================== 输入 /help 查看命令,直接输入文字开始聊天 你:你好 AI:你好!很高兴见到你。我是由 EXAMPLE 提供技术支持的 AI 助手,有什么可以帮你的吗? 你:/stats ======================================== 对话统计 ======================================== 模型:gpt-3.5-turbo 消息数:2 总 tokens:50 估算费用:$0.0001 ======================================== 你:/quit 再见!Weitere Erweiterungen