DeepSeek API Python-Beispiel: Chat, Streaming, Tools

Installieren und erste Anfrage senden

Dieser Dienst ist nicht die offizielle DeepSeek-API. Es ist ein gehosteter, OpenAI-kompatibler Endpunkt, der ein Open-Weight-Modell mit der ID uncensored ausführt, betrieben von einem unabhängigen Anbieter. Da er dem OpenAI-Format folgt, funktioniert das Standard-Python-SDK ohne Änderungen außer der URL und dem Schlüssel.

Copypip install openai

Hole einen Schlüssel von der API-Schlüssel-Seite. Nach der Anmeldung kannst du mit einem Klick $0,50 an Testguthaben beanspruchen, ohne Kreditkarte, 7 Tage gültig. Speichere den Schlüssel in einer Umgebungsvariable und nicht in der Quelldatei:

Copyexport API_KEY="YOUR_KEY"

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.deepseekapi.top/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain list comprehensions in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Die beiden Nutzungszahlen sind die Grundlage deiner Abrechnung. Multipliziere sie mit den Preisen, um die Kosten für jede Anfrage zu sehen: Input-Token mal $0,15 und Output-Token mal $0,50, jeweils geteilt durch 1.000.000.

Den Async-Client verwenden

Für Webserver und alles, das viele Benutzer verarbeitet, verwende den Async-Client. Er hat dieselben Parameter wie der Sync-Client und ist in den meisten Code-Basen ein sofort einsetzbarer Wechsel.

Copyimport asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.deepseekapi.top/v1",
    api_key=os.environ["API_KEY"],
)

sem = asyncio.Semaphore(8)

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = ["Define idempotent.", "Define monotonic.", "Define pure function."]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    for a in answers:
        print(a)

asyncio.run(main())

Der Semaphore ist auf 8 gesetzt, da dies die Concurrency eines vollständigen Schlüssels ist. Verwende bei einem Trial-Schlüssel 2. Ohne Begrenzung erzeugt ein Burst von Aufgaben concurrency-Fehler, obwohl jede Anfrage gültig ist.

Streaming-Antworten

Setze stream=True und der Endpunkt sendet Server-Sent Events. Jeder Chunk enthält ein kleines Textstück in delta.content. Die Anforderung von Usage bedeutet, dass der letzte Chunk Token-Anzahlen meldet.

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a haiku about debugging."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Zwei Details bringen Leute durcheinander. Der finale Usage-Chunk kann eine leere choices-Liste haben, weshalb die Schleife zuerst chunk.choices prüft. Und eine gestreamte Anfrage behält ihren Concurrency-Slot bis zum Stream-Ende, also brich Schleifen sauber ab und schließe verlassene Streams. Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen; ein Trial-Schlüssel erlaubt 2.

JSON-Modus

Für Ausgaben, die ein Programm parsen soll, verwende response_format mit json_object. Erwähne auch das Wort JSON im Prompt und beschreibe die gewünschte Struktur. Das Modell benötigt diese Anweisung; das Flag allein liefert kein Schema.

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import json

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": str, \"tags\": [str]}"},
        {"role": "user", "content": "Summarize: a guide to caching HTTP responses."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Umschließe json.loads mit try/except. Wenn eine Antwort durch ein Token-Limit abgeschnitten wird, lässt sie sich nicht parsen, also vermeide ein kleines max_tokens mit JSON. Setze temperature auf 0 und einen seed, um Wiederholungen reproduzierbarer zu machen, da beide durchgereicht werden.

Function Calling

Die API akzeptiert tools und tool_choice und gibt tool_calls in der Assistenten-Nachricht zurück. Du führst die Funktion selbst aus und sendest das Ergebnis als Nachricht mit role: "tool" zurück.

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import json

tools = [{
    "type": "function",
    "function": {
        "name": "add",
        "description": "Add two numbers.",
        "parameters": {
            "type": "object",
            "properties": {"a": {"type": "number"}, "b": {"type": "number"}},
            "required": ["a", "b"],
        },
    },
}]

messages = [{"role": "user", "content": "What is 17.5 plus 24.25?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = args["a"] + args["b"]
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": str(result),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

Parsiere arguments immer defensiv. Es ist ein vom Modell erzeugter JSON-String, und ein fehlerhafter String ist möglich. Validiere ihn, bevor du darauf reagierst, besonders wenn die Funktion Dateien oder eine Datenbank berührt.

Fehler, Limits und Wiederholungen

Eine Anfrage über einem Limit gibt HTTP 429 zurück. Der Fehlercode sagt dir, welches Limit: rate_limited für Anfragen pro Minute (300 auf einem vollständigen Schlüssel, 60 auf einem Trial-Schlüssel) und concurrency für zu viele gleichzeitig. Bei temporärer Überlastung erhältst du auch 429 mit Retry-After: 5. Das SDK löst openai.RateLimitError aus.

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import time
import openai

def ask(prompt, tries=4):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except openai.RateLimitError as e:
            wait = int(e.response.headers.get("Retry-After", 5))
            time.sleep(wait * (attempt + 1))
    raise RuntimeError("still rate limited")

print(ask("Name three Python web frameworks."))

Wenn du viele Anfragen sendest, begrenze deine eigene Parallelität mit einem Semaphore oder einem Thread-Pool mit 8 Workern, oder 2 auf einem Trial-Schlüssel. Das vermeidet concurrency-Fehler statt sie per Retry zu umgehen.

Header lesen

Jede Antwort enthält X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests und X-RateLimit-Limit-Concurrency. Das SDK macht sie über die Rohantwort verfügbar:

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "ping"}],
)
print(raw.headers.get("X-Balance-USD"), raw.headers.get("X-Request-Id"))
completion = raw.parse()

Das Protokollieren der Request-ID bei jedem Fehler macht Support-Fragen viel einfacher zu beantworten. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet.

Eine Konversation am Laufen halten

Die API ist zustandslos. Sie erinnert sich nicht an frühere Anfragen, daher bedeutet ein Multi-Turn-Chat, dass du die gesamte Historie jedes Mal sendst. Halte eine Liste und füge ihr Elemente hinzu:

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
history = [{"role": "system", "content": "You are a helpful tutor."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("What is a closure?"))
print(chat("Show me one in Python."))

Jeder Turn sendet alles erneut, also wachsen die Input-Token Schritt für Schritt. Kürze alte Nachrichten, sobald die Liste lang wird, oder bitte das Modell, den frühen Teil zusammenzufassen und ihn zu ersetzen. Mit einem 100.000-Token-Fenster hast du viel Platz, aber die Rechnung wächst mit der Historie, daher ist eine gekürzte Liste günstiger.

Sampling-Werte wählen

Verwende temperature 0 bis 0,3 für Code und Extraktion, etwa 0,7 für allgemeinen Chat und höher für Fiktion. top_p, stop, seed und die Frequency- und Presence-Penalties werden durchgereicht, also verhalten sie sich wie in der OpenAI-Dokumentation beschrieben. Ändere immer nur einen Parameter und vergleiche.

Kosten und Kontext planen

Das Kontextfenster umfasst 100.000 Token, Prompt plus Completion, und das Limit für den Request-Body beträgt 8 MB. Completion kann den Rest des Fensters nutzen, und max_tokens ist optional. Es ist jedoch gute Praxis, es zu setzen, insbesondere für Batch-Jobs.

Ein durchgerechnetes Beispiel: ein Batch von 1.000 Zusammenfassungen, jede mit 1.500 Input-Token und 200 Output-Token.

• Input: 1.000 × 1.500 = 1.500.000 Token, was 1,5 × $0,15 = $0,225 entspricht
• Output: 1.000 × 200 = 200.000 Token, was 0,2 × $0,50 = $0,10 entspricht
• Gesamt: $0,325

Die Preise sind Pay as you go vom Prepaid-Guthaben, ohne Abonnement, und das Guthaben verfällt nie. Aufladungen laufen von $20 bis $500 in ganzen Beträgen, mit +5% ab $50, +10% ab $100 und +15% ab $200, zahlbar mit Karte oder Krypto. Sieh dir die Preisseite an und die Quickstart-Dokumentation für curl- und Node-Beispiele. Wenn du nur deinen Schlüssel finden musst, behandelt die API-Schlüssel-Übersicht das Thema.

Prompts werden nicht zum Training verwendet. Der Dienst ist nur Text: keine Bilder, Audio, Embeddings oder Fine-Tuning, plane also nicht um diese Endpunkte herum.

Weitere Anleitungen

• So nutzt du die DeepSeek API in Cursor: Einrichtung der benutzerdefinierten Base URL
• So verwendest du die DeepSeek API in SillyTavern: Custom Endpoint
• DeepSeek API-Schlüssel: Zugriff auf die unzensierte LLM-API