FR ▾
Obtenir une clé API
https://api.deepseekapipricing.com/v1

Configuration de l'API DeepSeek avec LangChain : Python et Node

Pour une configuration de l'API DeepSeek avec LangChain, vous avez seulement besoin de la classe ChatOpenAI, d'une URL de base, d'une clé et du nom du modèle. Ce guide couvre le code Python et Node pour le chat, le streaming, l'appel de fonctions, la sortie JSON et la concurrence, en utilisant un endpoint indépendant compatible OpenAI plutôt que l'API du fournisseur.

Mis à jour le

Chaînes lumineuses connectant des serveurs à des bulles de chat, représentant une intégration LangChain avec une API

Points clés

  1. Utilisez ChatOpenAI avec base_url défini sur https://api.deepseekapipricing.com/v1 et le modèle uncensored.
  2. Passez api_key de manière explicite pour qu'une clé OpenAI présente dans votre environnement ne soit jamais envoyée ici.
  3. Le streaming, bind_tools et le mode JSON fonctionnent via les paramètres standard au format OpenAI.
  4. Limitez max_concurrency à 8 pour une clé complète, ou à 2 pour une clé d'essai, pour éviter les erreurs 429.

Ce dont vous avez besoin avant de commencer

LangChain communique avec n'importe quel serveur implémentant le protocole de complétion de chat OpenAI, donc aucune intégration spéciale n'est à installer. Votre point de départ est le même package que vous utiliseriez pour OpenAI lui-même : langchain-openai pour Python ou @langchain/openai pour Node. Seules trois valeurs changent.

  • URL de base : https://api.deepseekapipricing.com/v1
  • Modèle : uncensored
  • Clé : envoyée en tant que Authorization: Bearer <key>, ce que le client fait pour vous

Une précision sur le nommage. Cet endpoint est un service indépendant exécutant un modèle à poids ouverts, conçu pour répondre sans refus de contenu pour un usage adulte légal. Ce n'est pas l'API officielle DeepSeek et ce n'est pas un routeur entre fournisseurs, donc le nom du modèle est toujours uncensored, et non un ID de modèle de fournisseur. Si vous avez besoin d'une clé, la page clé API montre les étapes d'inscription et l'essai gratuit de 0,50 $ en un clic.

Installez et effectuez le premier appel en Python

Installez les packages :

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

Puis créez l'objet modèle. Transmettez la clé explicitement au lieu de vous fier à la variable d'environnement OPENAI_API_KEY, qui peut contenir une vraie clé OpenAI que vous ne voulez pas envoyer à un hôte différent.

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)

Si cela affiche un message de bienvenue, la connexion, la clé et le nom du modèle sont corrects. L'erreur la plus courante à ce stade est d'oublier /v1 dans l'URL de base, ce qui produit généralement une erreur not-found.

Prompts, chaînes et streaming

À partir de là, LangChain fonctionne comme d'habitude. Un prompt template, le modèle et un output parser se composent en une chaîne avec l'opérateur pipe :

# 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"}))

Le streaming passe par les événements envoyés par le serveur. Dans LangChain, vous appelez stream, et chaque chunk contient un morceau de texte. Définissez stream_usage=True sur le modèle si vous voulez les compteurs de tokens à la fin du stream ; l'API envoie l'utilisation dans l'événement final.

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)

Une requête en streaming conserve son slot de concurrence jusqu'à la fin du stream, donc si vous abandonnez un stream sans le fermer, ce slot reste occupé plus longtemps que prévu.

Node et TypeScript

Le package JavaScript prend l'URL de base à l'intérieur d'un objet configuration :

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);
}

Exécutez-le en tant que module ES ("type": "module" dans package.json, ou un fichier .mjs). Tout le reste de l'API Node, y compris les prompts et les runnables, se comporte comme avec n'importe quel autre modèle de chat.

Appel de fonctions et agents

L'API prend en charge le format d'outils OpenAI : les paramètres tools et tool_choice, les tool_calls en streaming, et les résultats d'outils retournés en tant que messages avec role: "tool". Dans LangChain, vous déclarez les outils avec un décorateur et les attachez avec 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)

Écrire la boucle à la main une fois vaut les dix minutes. Cela vous montre exactement ce que le modèle a retourné, quels arguments il a choisis pour chaque appel, et où une mauvaise description d'outil conduit à une mauvaise estimation. Une fois cela clair, passez à un agent préconstruit et gardez la version écrite à la main comme référence de débogage.

C'est la boucle manuelle : le modèle demande un outil, vous l'exécutez, retournez le résultat, et le modèle écrit la réponse finale. Pour une boucle d'agent prête à l'emploi, le package langgraph propose create_react_agent(llm, [order_status]), invoqué avec {"messages": [("user", "Where is order 1042?")]}.

La capacité d'un modèle à choisir des outils dépend du modèle, donc testez avec vos vrais schémas d'outils. Des descriptions d'outils courtes et spécifiques et une température faible aident. Un agent qui fait six appels avec un historique croissant d'environ 27 000 tokens d'entrée au total et 1 800 tokens de sortie coûte environ $0,00405 plus $0,0009, soit environ un demi-centime.

Sortie structurée avec le mode JSON

Le mode JSON est pris en charge via response_format. Liez-le au modèle et dites aussi dans le prompt que vous voulez du JSON avec des clés spécifiques, car le drapeau de format contrôle la syntaxe, pas votre schéma :

# 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"])

Validez le résultat analysé avec Pydantic ou vos propres vérifications avant de lui faire confiance, et gérez json.JSONDecodeError avec un réessai. Pour les tâches d'extraction volumineuses, analysez chaque réponse de manière défensive plutôt que de supposer que la première est propre.

Récupération, mémoire et callbacks

Cette API n'a pas d'endpoint d'embeddings, donc un pipeline de récupération a besoin d'une source séparée d'embeddings. Tout ce qui suit la récupération est du chat classique. Une chaîne de récupération typique récupère les meilleurs passages de votre magasin vectoriel, les insère dans le prompt, et demande au modèle de répondre à partir de ce texte. Comme la fenêtre de contexte est de 100 000 tokens, vous pouvez vous permettre des passages généreux, mais rappelez-vous la facture : chaque token de contexte récupéré est de l'entrée à 0,15 $ par million, donc 20 000 tokens de contexte coûtent 0,003 $ par question.

Pour la mémoire de chat, l'approche la plus simple est une liste de messages que vous réduisez par comptage de tokens avant chaque appel. LangChain propose des assistants tels que trim_messages pour cela. Conservez le message système et les derniers tours, et supprimez ou résumez le milieu une fois que l'historique atteint une limite que vous choisissez. Un historique plus petit maintient également les réponses ciblées, et il réduit le coût de chaque tour, car tout l'historique est renvoyé en entrée à chaque fois.

Les callbacks sont l'endroit où enregistrer le coût d'un appel. Chaque réponse inclut un bloc d'utilisation avec les tokens de prompt et de complétion, et dans LangChain le message retourné le porte dans 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}")

Enregistrez le coût avec l'ID de requête pour qu'une facture surprenante puisse être tracée à une chaîne.

Prompts système et ton

Le modèle n'a pas de refus de contenu intégrés, donc le message système est l'endroit où vous définissez le comportement de votre produit : le persona, le ton, les sujets à éviter et le format de la réponse. Écrivez-le comme vous le feriez pour un brief à un nouveau collègue. Court et spécifique fonctionne mieux que long et vague. Le contenu impliquant des mineurs est une limite stricte sur ce service, donc ne construisez pas de prompts qui s'en approchent.

Une courte liste de contrôle avant de livrer

  • La clé vit dans une variable d'environnement ou un magasin de secrets, jamais dans le dépôt.
  • max_concurrency est défini à la limite de votre clé, ou en dessous si d'autres services partagent la clé.
  • Les réessais utilisent un court back-off, et les réponses 429 avec Retry-After: 5 sont honorées.
  • Les streams sont fermés à la déconnexion du client pour libérer les slots.
  • Les sorties JSON sont analysées de manière défensive et validées.
  • Les coûts sont enregistrés par chaîne à partir du bloc d'utilisation.
  • Un fallback existe pour le cas où l'endpoint est inaccessible, même si le fallback est un message d'erreur.

Suivez cette liste et l'intégration se comportera comme n'importe quel autre modèle de chat LangChain. La différence est du côté du contenu, où les requêtes que d'autres modèles refusent pour un usage adulte légal obtiennent une réponse.

Limites de débit, concurrence et erreurs courantes

Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 requêtes simultanées et 60 par minute. Le corps de la requête peut faire jusqu'à 8 Mo, et la fenêtre de contexte est de 100 000 tokens couvrant le prompt et la complétion ensemble.

Les helpers de batch de LangChain répartissent les requêtes en parallèle, donc définissez un plafond qui correspond à votre clé :

# 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})

Utilisez 2 au lieu de 8 sur une clé d'essai. Lorsque vous dépassez une limite, l'API retourne HTTP 429 avec le code d'erreur rate_limited (trop de requêtes par minute) ou concurrency (trop à la fois). En cas de surcharge temporaire, elle retourne aussi 429, avec un en-tête Retry-After: 5. Le paramètre max_retries dans le client gère les cas transitoires, mais si vous voyez le code d'erreur concurrency à plusieurs reprises, réduisez max_concurrency au lieu d'ajouter des réessais.

  • Erreurs not-found à chaque appel : vérifiez que l'URL de base se termine par /v1.
  • Erreur d'authentification : la clé est manquante ou contient une faute de frappe ; confirmez qu'elle est passée via api_key.
  • Erreurs de modèle : le nom du modèle doit être exactement uncensored.
  • Exécutions de batch lentes : les streams bloqués retiennent les slots de concurrence, donc fermez-les ou définissez un timeout.

La tarification est de 0,15 $ par million de tokens d'entrée et de 0,50 $ par million de tokens de sortie, et les requêtes échouées ou refusées ne sont pas facturées. La page tarification liste les recharges, et la documentation couvre chaque paramètre et les en-têtes de réponse, y compris X-Request-Id et X-Balance-USD, qui sont pratiques à journaliser dans un callback LangChain.

01

Questions et réponses

Quelle classe LangChain dois-je utiliser ?

Utilisez ChatOpenAI depuis langchain-openai en Python, ou ChatOpenAI depuis @langchain/openai dans Node. Définissez l'URL de base sur https://api.deepseekapipricing.com/v1 et le modèle sur uncensored.

Le streaming fonctionne-t-il avec LangChain ?

Oui. L'API diffuse en SSE et envoie les données d'utilisation à la fin, donc llm.stream fonctionne. Définissez stream_usage=True si vous souhaitez obtenir les compteurs de tokens dans le flux.

Puis-je utiliser des embeddings ou des magasins vectoriels ici ?

Non depuis cette API. Elle est textuelle uniquement et n'a pas d'endpoint d'embeddings, donc utilisez une source d'embedding séparée pour la récupération et envoyez le texte récupéré ici.

Pourquoi obtiens-je une erreur HTTP 429 ?

Vous avez soit dépassé la limite par minute (rate_limited), envoyé trop de requêtes à la fois (concurrency), ou le fournisseur était brièvement surchargé. Réduisez max_concurrency et respectez Retry-After.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé API