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-MethodeZweckBeispiel in KI-APIs
POSTEine Ressource erstellenChat-Anfragen senden, Bilder generieren
GETEine Ressource abrufenModelllisten abfragen, Abrechnungsinformationen abrufen
DELETEEine Ressource löschenKonversationsverlauf 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:

EditorFunktionenZielbenutzer
VS CodeKostenlos, reichhaltiges Plugin-Ökosystem, leichtgewichtigDie meisten Entwickler
CursorIntegrierte KI-Unterstützung, kann direkt Code generierenFür diejenigen, die KI beim Schreiben von Code nutzen möchten
PyCharmFunktionsreichste, beste Python-UnterstützungProfessionelle 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

# Dateipfad: first_api_call.py
# 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

from openai import OpenAI

# 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:

ParameternameTypeErforderlichBeschreibungStandardwert
modelstringJaDie zu verwendende Modell-ID, wie gpt-3.5-turbo, gpt-4Keine
messagesarrayJaListe der Nachrichten des KonversationsverlaufsKeine
temperaturenumberneinSampling-Temperatur, zwischen 0-2. Je höher, desto zufälliger; je niedriger, desto deterministischer.1.0
max_tokensintegerneinMaximale Anzahl der zu generierenden TokensUnbegrenzt
top_pnumberneinNucleus-Sampling-Parameter, zwischen 0-11.0
stopstring/arrayneinStoppsequenz; Generierung stoppen, wenn diese Zeichen auftretennull

Konzentrieren wir uns auf temperature, den am häufigsten verwendeten Anpassungsparameter:

Beispiele

# Dateipfad: temperature_demo.py
# 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:

VergleichspunktOpenAI APIClaude API
Nachrichtenstruktursystem, user, assistant wechseln sich absystem wird separat festgelegt, user und assistant wechseln sich ab
Kontextlänge16k-128k variiertClaude 3 Serie unterstützt 200k
Parameterdesigntemperature, 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

# Dateipfad: claude_first_call.py
# 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

import anthropic

# 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

# Dateipfad: claude_system_prompt.py
# 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

# Dateipfad: multi_turn_chat.py
# 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

# Dateipfad: context_management.py
# 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:

StrategieVorteileNachteileAnwendbare Szenarien
Nur die neuesten N Einträge behaltenEinfach, schnellKann wichtige Informationen verlierenKurze Konversationen, lockere Chat-Szenarien
KI verwenden, um den Verlauf zusammenzufassenBewahrt semantische InformationenErfordert zusätzliche API-AufrufeLange Konversationen, viele wichtige Informationen
Gleitendes FensterBalanciert Einfachheit und VollständigkeitEtwas komplexer zu implementierenAllgemeiner 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

# Dateipfad: streaming_demo.py
# 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

# Dateipfad: claude_streaming.py
# 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

# Dateipfad: cost_tracking.py
# 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:

TippWie man es umsetztEinsparquote
Wählen Sie das richtige ModellVerwenden Sie gpt-3.5-turbo für einfache Aufgaben, nicht gpt-490%+
max_tokens begrenzenLegen Sie eine vernünftige Obergrenze fest, damit die KI nicht zu viel sagtKommt auf die Situation an
Kontext kürzenNur den notwendigen Gesprächsverlauf behalten50%+
Prompts knapp haltenMachen Sie den System-Prompt nicht zu langKommt auf die Situation an
Ergebnis-CachingFür identische Fragen direkt zwischengespeicherte Ergebnisse zurückgebenKommt auf die Situation an

Caching-Strategien

Bei wiederholten Fragen kann das Zwischenspeichern von Ergebnissen viel Geld sparen:

Beispiele

# Dateipfad: response_cache.py
# 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

FehlertypHTTP-StatuscodeUrsacheBehandlungsmethode
Authentifizierungsfehler401API-Schlüssel falsch oder abgelaufenAPI-Schlüssel prüfen
Unzureichendes Kontingent402Konto hat kein GuthabenAufladen oder Konto wechseln
Limit überschritten429Anfrage zu schnell oder Kontingent erschöpftEine Weile warten und erneut versuchen
Serverfehler5xxProblem auf KI-ServerseiteWiederholen

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

# Dateipfad: error_handling.py
# 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

# Dateipfad: tenacity_demo.py
# 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

# Dateipfad: example_chatbot.py
# 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