DE ▾
API-Schlüssel erhalten
https://api.deepseekapipricing.com/v1

DeepSeek API LangChain-Einrichtung: Python und Node

Für eine DeepSeek API LangChain-Einrichtung benötigst du nur die ChatOpenAI-Klasse, eine Base URL, einen Schlüssel und den Modellnamen. Dieser Leitfaden behandelt Python- und Node-Code für Chat, Streaming, Tool Calling, JSON-Ausgabe und Concurrency, über einen unabhängigen OpenAI-kompatiblen Endpunkt statt der eigenen API des Anbieters.

Aktualisiert

Leuchtende Kettenverbindungen, die Server mit Chat-Blasen verbinden, repräsentieren eine LangChain-Integration mit einer API

Wichtige Punkte

  1. Verwende ChatOpenAI mit base_url, das auf https://api.deepseekapipricing.com/v1 gesetzt ist, und dem Modell uncensored.
  2. Gib api_key explizit an, damit ein OpenAI-Schlüssel in deiner Umgebung niemals hierher gesendet wird.
  3. Streaming, bind_tools und JSON-Modus funktionieren über die Standard-OpenAI-Formatparameter.
  4. Begrenze max_concurrency auf 8 für einen Vollschlüssel oder auf 2 für einen Trial-Schlüssel, um 429-Fehler zu vermeiden.

Was du vor dem Start benötigst

LangChain kommuniziert mit jedem Server, der das OpenAI-Chat-Vervollständigungsprotokoll implementiert, daher muss keine spezielle Integration installiert werden. Dein Ausgangspunkt ist das gleiche Paket, das du für OpenAI selbst verwenden würdest: langchain-openai für Python oder @langchain/openai für Node. Nur drei Werte ändern sich.

  • Base URL: https://api.deepseekapipricing.com/v1
  • Modell: uncensored
  • Schlüssel: gesendet als Authorization: Bearer <key>, was der Client für dich erledigt

Eine Klarstellung zur Namensgebung. Dieser Endpunkt ist ein unabhängiger Dienst, der ein Open-Weight-Modell ausführt, das darauf abgestimmt ist, ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle DeepSeek-API und kein Router über verschiedene Anbieter hinweg, daher ist der Modellname immer uncensored, keine Anbieter-Modellkennung. Wenn du einen Schlüssel benötigst, zeigt die API-Schlüssel-Seite die Anmeldungsschritte und das ein-Klick-$0,50-Testguthaben.

Installiere und führe den ersten Aufruf in Python aus

Installiere die Pakete:

pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"

Erstelle dann das Modellobjekt. Gib den Schlüssel explizit an, anstatt dich auf die Umgebungsvariable OPENAI_API_KEY zu verlassen, die einen echten OpenAI-Schlüssel enthalten könnte, den du nicht an einen anderen Host senden möchtest.

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.deepseekapipricing.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    temperature=0.7,
    max_retries=2,
)

print(llm.invoke("Say hello in five words.").content)

Wenn dies eine Begrüßung ausgibt, sind Verbindung, Schlüssel und Modellname korrekt. Der häufigste Fehler in dieser Phase ist das Weglassen von /v1 in der Base URL, was typischerweise einen Not-Found-Fehler erzeugt.

Prompts, Chains und Streaming

Von hier aus funktioniert LangChain wie üblich. Eine Prompt-Vorlage, das Modell und ein Output-Parser setzen sich mit dem Pipe-Operator zu einer Chain zusammen:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You write tight, vivid scene descriptions for adult fiction."),
    ("human", "Describe this setting in under 80 words: {setting}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))

Streaming erfolgt über Server-Sent Events. In LangChain rufst du stream auf, und jeder Chunk enthält ein Textstück. Setze stream_usage=True im Modell, wenn du Token-Anzahlen am Ende des Streams möchtest; die API sendet die Nutzung im letzten Event.

llm_stream = ChatOpenAI(
    model="uncensored",
    base_url="https://api.deepseekapipricing.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    stream_usage=True,
)

for chunk in llm_stream.stream("Write a four-line poem about a night train."):
    print(chunk.content, end="", flush=True)

Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn du einen Stream abbrichst, ohne ihn zu schließen, bleibt dieser Slot länger belegt, als du erwarten würdest.

Node und TypeScript

Das JavaScript-Paket erwartet die Base URL innerhalb eines configuration-Objekts:

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.UNCENSORED_API_KEY,
  configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
  maxRetries: 2,
});

const res = await llm.invoke("Say hello in five words.");
console.log(res.content);

const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

Führe es als ES-Modul aus ("type": "module" in package.json oder eine .mjs-Datei). Alles andere in der Node API, einschließlich Prompt-Vorlagen und Runnables, verhält sich wie bei jedem anderen Chat-Modell.

Tool Calling und Agents

Die API unterstützt das OpenAI-Tool-Format: die Parameter tools und tool_choice, gestreamte tool_calls und Tool-Ergebnisse, die als Nachrichten mit role: "tool" zurückgegeben werden. In LangChain deklarierst du Tools mit einem Decorator und verknüpfst sie mit bind_tools:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage

@tool
def order_status(order_id: str) -> str:
    """Return the shipping status of an order."""
    return f"Order {order_id} left the warehouse yesterday."

llm_tools = llm.bind_tools([order_status])

messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)

for call in ai.tool_calls:
    result = order_status.invoke(call["args"])
    messages.append(ToolMessage(content=result, tool_call_id=call["id"]))

print(llm_tools.invoke(messages).content)

Den Loop einmal manuell zu schreiben, ist die zehn Minuten wert. Es zeigt dir genau, was das Modell zurückgegeben hat, welche Argumente es für jeden Aufruf gewählt hat und wohin eine schlechte Tool-Beschreibung zu einer falschen Schätzung führt. Sobald das klar ist, wechsle zu einem vorgefertigten Agenten und behalte die manuell geschriebene Version als Debugging-Referenz.

Das ist die gesamte Schleife von Hand: Das Modell fragt ein Tool an, du führst es aus, gibst das Ergebnis zurück und das Modell schreibt die finale Antwort. Wenn du eine fertige Agent-Schleife bevorzugst, bietet das langgraph-Paket create_react_agent(llm, [order_status]) an, und du rufst es mit {"messages": [("user", "Where is order 1042?")]} auf.

Wie gut ein Modell Tools auswählt, hängt vom Modell ab, also teste mit deinen echten Tool-Schemas. Kurze, spezifische Tool-Beschreibungen und eine niedrige Temperatur helfen. Ein Agent, der sechs Aufrufe mit einer wachsenden Historie von insgesamt etwa 27.000 Input-Token und 1.800 Output-Token macht, kostet etwa $0,00405 plus $0,0009, also etwa einen halben Cent.

Strukturierte Ausgabe mit JSON-Modus

JSON-Modus wird über response_format unterstützt. Binde es an das Modell und sage im Prompt auch, dass du JSON mit bestimmten Schlüsseln möchtest, da das Format-Flag die Syntax steuert, nicht dein Schema:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json

json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke(
    "Return a JSON object with keys title (string) and tags (list of 3 strings) "
    "for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])

Validiere das analysierte Ergebnis mit Pydantic oder deinen eigenen Prüfungen, bevor du ihm vertraust, und behandle json.JSONDecodeError mit einem Retry. Für große Extraktionsaufgaben analysiere jede Antwort defensiv, anstatt anzunehmen, dass die erste sauber ist.

Retrieval, Speicher und Callbacks

Diese API hat keinen Embedding-Endpunkt, daher benötigt eine Retrieval-Pipeline eine separate Quelle für Embeddings. Alles nach dem Retrieval ist normaler Chat. Eine typische Retrieval-Kette zieht die wichtigsten Textpassagen aus deinem Vektorspeicher, fügt sie in den Prompt ein und bittet das Modell, basierend auf diesem Text zu antworten. Da das Kontextfenster 100.000 Token umfasst, kannst du großzügige Passagen verwenden, aber denk an die Rechnung: Jeder Token des abgerufenen Kontexts ist Eingabe-Token zu $0,15 pro Million, also kosten 20.000 Token Kontext $0,003 pro Frage.

Für Chat-Speicher ist der einfachste Ansatz eine Nachrichtenliste, die du vor jedem Aufruf nach Token-Anzahl kürzt. LangChain bietet Helfer wie trim_messages dafür an. Behalte die Systemnachricht und die neuesten Turns bei und lösche oder fasse die Mitte zusammen, sobald die Historie ein von dir gewähltes Limit erreicht. Eine kleinere Historie hält die Antworten auch fokussierter und senkt die Kosten für jeden Turn, da die gesamte Historie jedes Mal als Input erneut gesendet wird.

Callbacks sind der Ort, um zu protokollieren, was ein Aufruf gekostet hat. Jede Antwort enthält einen usage-Block mit Prompt- und Completion-Token, und in LangChain trägt die zurückgegebene Nachricht dies in usage_metadata:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")

Protokolliere die Kosten mit der Request-ID, damit eine überraschende Rechnung auf eine Chain zurückgeführt werden kann.

System-Prompts und Tonfall

Das Modell hat keine integrierten Inhaltsablehnungen, daher ist die Systemnachricht der Ort, an dem du das Verhalten deines Produkts festlegst: die Persona, den Tonfall, die Themen, die es vermeiden soll, und das Format der Antwort. Schreibe sie so, wie du einen Auftrag für einen neuen Kollegen schreiben würdest. Kurz und spezifisch funktioniert besser als lang und vage. Inhalte mit Minderjährigen sind eine harte Grenze auf diesem Dienst, also baue keine Prompts, die sich diesem nähern.

Eine kurze Checkliste vor dem Release

  • Der Schlüssel lebt in einer Umgebungsvariable oder einem Secret-Store, niemals im Repository.
  • max_concurrency ist auf das Limit deines Schlüssels gesetzt oder darunter, wenn andere Dienste den Schlüssel teilen.
  • Retries verwenden einen kurzen Backoff, und 429-Antworten mit Retry-After: 5 werden beachtet.
  • Streams werden bei Client-Trennung geschlossen, damit Slots freigegeben werden.
  • JSON-Ausgaben werden defensiv analysiert und validiert.
  • Kosten werden pro Chain aus dem usage-Block protokolliert.
  • Es gibt einen Fallback für den Fall, dass der Endpunkt nicht erreichbar ist, auch wenn der Fallback eine Fehlermeldung ist.

Folge dieser Liste, und die Integration verhält sich wie jedes andere LangChain-Chat-Modell. Der Unterschied liegt auf der Inhaltseite, wo Anfragen, die andere Modelle für die rechtmäßige Nutzung durch Erwachsene ablehnen, beantwortet werden.

Ratenlimits, Concurrency und häufige Fehler

Ein Vollschlüssel erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Ein Trial-Schlüssel erlaubt 2 gleichzeitige Anfragen und 60 pro Minute. Der Request-Body kann bis zu 8 MB groß sein, und das Kontextfenster umfasst 100.000 Token, die Prompt und Completion zusammen abdecken.

LangChains Batch-Helfer verteilen Anfragen parallel, also setze eine Obergrenze, die zu deinem Schlüssel passt:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})

Verwende 2 statt 8 auf einem Trial-Schlüssel. Wenn du ein Limit überschreitest, gibt die API HTTP 429 mit dem Fehlercode rate_limited (zu viele Anfragen pro Minute) oder concurrency (zu viele auf einmal) zurück. Bei temporärer Überlastung gibt sie ebenfalls 429 zurück, mit einem Retry-After: 5-Header. Die Einstellung max_retries im Client behandelt vorübergehende Fälle, aber wenn du den Fehlercode concurrency wiederholt siehst, reduziere max_concurrency statt mehr Retries hinzuzufügen.

  • Not-found-Fehler bei jedem Aufruf: Überprüfe, ob die Base URL mit /v1 endet.
  • Authentifizierungsfehler: Der Schlüssel fehlt oder hat einen Tippfehler; bestätige, dass er über api_key übergeben wird.
  • Modellfehler: Der Modellname muss genau uncensored sein.
  • Langsame Batch-Läufe: Hängende Streams belegen Concurrency-Slots, also schließe sie oder setze einen Timeout.

Die Preise liegen bei $0,15 pro Million Eingabe-Token und $0,50 pro Million Ausgabe-Token, und fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet. Die Preisseite listet Aufladungen auf, und die Dokumentation behandelt jeden Parameter und die Antwort-Header, einschließlich X-Request-Id und X-Balance-USD, die sich gut für ein LangChain-Callback eignen.

01

Fragen und Antworten

Welche LangChain-Klasse soll ich verwenden?

Verwende ChatOpenAI aus langchain-openai in Python oder ChatOpenAI aus @langchain/openai in Node. Setze die Base URL auf https://api.deepseekapipricing.com/v1 und das Modell auf uncensored.

Funktioniert Streaming mit LangChain?

Ja. Die API streamt über SSE und sendet die Nutzungsinformationen am Ende, daher funktioniert llm.stream. Setze stream_usage=True, wenn du Token-Anzahlen im Stream möchtest.

Kann ich hier Embeddings oder Vektorspeicher verwenden?

Nicht über diese API. Sie ist nur für Text ausgelegt und hat keinen Embedding-Endpunkt, verwende also eine separate Embedding-Quelle für Retrieval und sende den abgerufenen Text hierher.

Warum erhalte ich HTTP 429?

Entweder hast du das Limit pro Minute überschritten (rate_limited), zu viele Anfragen gleichzeitig gesendet (concurrency) oder der Anbieter war kurzzeitig überlastet. Reduziere max_concurrency und beachte Retry-After.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Base URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten