LangChain et LangGraph sans clé API

Ce que « sans clé API » peut signifier concrètement

Rechercher langchain et langraph sans clé API signifie généralement l'une des trois choses suivantes. Vous souhaitez peut-être éviter de payer avant de savoir si la pile fonctionne. Vous ne voulez peut-être pas donner votre carte de crédit à un fournisseur de plus. Ou vous espérez peut-être exécuter un graphe d'agents sans aucune information d'identification.

La troisième demande ne peut pas être satisfaite par un service hébergé : un serveur qui effectue le travail pour vous doit savoir qui l'appelle. Ce que vous pouvez obtenir, c'est une clé qui ne coûte rien et qui ne demande aucune carte. Les nouveaux utilisateurs de ce site peuvent réclamer 0,50 $ de crédit d'essai gratuit en un clic sur la page clé API après s'être inscrits avec Google ou avec un e-mail et un mot de passe. Elle est valable une fois par personne et pendant 7 jours.

L'autre voie vers « sans clé » est un modèle local servi par un logiciel sur votre propre machine. Cela fonctionne, mais vous gérez le matériel, et un portable ne rivalisera pas avec un endpoint hébergé pour des exécutions d'agents longues. Un essai hébergé est le moyen le plus rapide de vérifier si la logique de votre graphe est solide, et le code que vous écrivez est identique à celui que vous exécuterez plus tard avec une clé financée.

Comme l'endpoint est compatible OpenAI, LangChain n'a pas besoin d'une intégration spéciale. Vous pointez sa classe de chat OpenAI vers une URL de base différente, lui donnez la clé et nommez le modèle uncensored. Tout ce qui suit suppose cette configuration.

Étape 1 : obtenir la clé d'essai et configurer l'environnement

Inscrivez-vous, ouvrez la page des clés et appuyez sur le bouton d'essai. Copiez la clé et gardez-la hors de votre dépôt. Placez-la dans une variable d'environnement pour que le même script fonctionne avec une clé d'essai aujourd'hui et une clé complète plus tard.

Copyexport UNCENSORED_API_KEY="paste-your-key-here"
pip install -U langchain-openai langgraph langchain-core

Avant d'impliquer tout framework, vérifiez la clé avec une requête simple. Deux minutes ici économisent une heure de lecture de piles d'erreurs qui sont en réalité des erreurs d'authentification.

Copycurl https://api.stableaudio.top/v1/chat/completions \
  -H "Authorization: Bearer $UNCENSORED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with one word: ready"}]}'

Un appel GET /v1/models est l'autre vérification rapide ; il doit lister uncensored. La clé d'essai permet 2 requêtes simultanées et 60 requêtes par minute, ce qui est largement suffisant pour développer un graphe mais vaut la peine d'être rappelé lorsque vous ajoutez des nœuds en parallèle.

Étape 2 : pointer LangChain vers l'endpoint

La classe à utiliser est ChatOpenAI de langchain-openai. Deux arguments font le travail : base_url et api_key. Le nom du modèle est uncensored, et les paramètres d'échantillonnage habituels sont transmis.

Copyimport os
from langchain_openai import ChatOpenAI

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

print(llm.invoke("Give me three titles for an ambient track about rain.").content)

Si cela affiche du texte, la connexion est bonne. Le streaming fonctionne de la même manière : itérez sur llm.stream(...) et les morceaux arrivent via les événements envoyés par le serveur, avec l'utilisation signalée à la fin du flux.

Une erreur courante consiste à laisser la variable OPENAI_API_KEY définie depuis un ancien projet. LangChain enverra volontiers cette valeur à votre URL de base personnalisée si vous oubliez de passer api_key. Passez la clé explicitement et vous éliminez les suppositions.

Étape 3 : un graphe LangGraph minimal

LangGraph modélise votre agent comme un état se déplaçant entre des nœuds. Le graphe utile le plus petit a un nœud qui appelle le modèle et ajoute la réponse à une liste de messages. MessagesState vous donne cette liste gratuitement.

Copyfrom langgraph.graph import StateGraph, MessagesState, START, END

def call_model(state: MessagesState):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_edge(START, "model")
builder.add_edge("model", END)
graph = builder.compile()

out = graph.invoke({"messages": [("user", "Outline a three-act short story about a lighthouse keeper.")]})
print(out["messages"][-1].content)

C'est délibérément simple. L'idée est que rien dans LangGraph ne sait ou ne se soucie de quel fournisseur se cache derrière llm. Chaque nœud peut prendre un objet de modèle différent, de sorte que vous pouvez plus tard donner à une étape de planification bon marché et à une étape d'écriture plus longue leurs propres paramètres, tels qu'une température plus faible pour la planification.

Étape 4 : ajouter des outils et une boucle

Les agents deviennent intéressants lorsque le modèle peut appeler des fonctions. L'endpoint prend en charge l'appel de fonctions avec tools et tool_choice, et les résultats d'appel de fonctions sont renvoyés sous forme de messages role: "tool". LangChain et LangGraph gèrent cette infrastructure pour vous.

Copyfrom langchain_core.tools import tool
from langgraph.prebuilt import ToolNode, tools_condition

@tool
def word_count(text: str) -> int:
    'Count the words in a piece of text.'
    return len(text.split())

tools = [word_count]
llm_with_tools = llm.bind_tools(tools)

def agent(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

builder = StateGraph(MessagesState)
builder.add_node("agent", agent)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")
graph = builder.compile()

result = graph.invoke({"messages": [("user", "Write a 40-word product blurb, then check its word count with the tool.")]})
print(result["messages"][-1].content)

La boucle est l'idée même : le nœud agent répond, tools_condition vérifie si la réponse a demandé un outil, le nœud outil l'exécute, et le contrôle revient à l'agent. Lorsqu'une réponse n'a pas d'appel d'outil, le graphe se termine.

Les modèles à poids ouverts varient dans la qualité de leurs arguments d'outil. Si un appel revient mal formé, serrez la docstring de l'outil, abaissez la température et gardez le schéma d'argument petit. Les schémas courts et typés échouent moins souvent que les longs avec de nombreux champs optionnels.

Limites de débit, tentatives et branches parallèles

L'endroit où les graphes d'agents tombent le plus souvent est la concurrence. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute ; une clé d'essai en permet 2 et 60. Si votre graphe s'étend en cinq nœuds parallèles sur une clé d'essai, trois d'entre eux seront rejetés avec HTTP 429 et le code d'erreur concurrency. Dépasser le budget par minute renvoie rate_limited. Une surcharge temporaire donne également un 429, avec un en-tête Retry-After: 5.

Trois habitudes rendent cela gérable :

• Conservez max_retries à 2 ou 3 sur ChatOpenAI afin que les erreurs 429 brèves soient réessayés avec un backoff.
• Limitez l'étalement à votre limite de concurrence. Dans LangGraph, vous pouvez passer config={"max_concurrency": 2} lors de l'appel du graphe.
• Rappelez-vous qu'une requête en streaming occupe son emplacement jusqu'à la fin du flux, donc un consommateur lent garde un emplacement occupé.

Copyout = graph.invoke(
    {"messages": [("user", "Draft five taglines in parallel.")]},
    config={"max_concurrency": 2},
)

Les en-têtes de réponse aident au débogage. X-Request-Id identifie un appel si vous devez demander du support à ce sujet, et X-Balance-USD affiche votre crédit restant après chaque requête.

Liste de vérification de débogage lorsque le graphe se comporte mal

La plupart des échecs dans un premier projet LangGraph ne concernent pas le modèle. Ils proviennent de la configuration, et une courte liste de vérification en attrape presque tous.

1. 401 ou erreurs d'authentification. La clé est manquante, mal tapée, ou une ancienne OPENAI_API_KEY est lue à la place. Imprimez les quatre premiers caractères de la valeur que votre script utilise réellement.
2. 404 ou modèle introuvable. Le nom du modèle doit être uncensored. Appelez GET /v1/models si vous n'êtes pas sûr de ce que l'endpoint liste.
3. Erreurs de connexion. L'URL de base doit se terminer par /v1 et ne doit pas inclure /chat/completions ; le client ajoute cette partie.
4. Boucles infinies. Si l'agent continue d'appeler un outil, la valeur de retour de l'outil peut ne pas répondre à la question. Retournez des chaînes simples et courtes et définissez une limite de récursivité via la configuration du graphe afin qu'une mauvaise boucle s'arrête tôt.
5. Réponses vides ou étranges. Imprimez la liste complète des messages après une exécution. Souvent, un nœud précédent a écrit un message système qui contredit le suivant.

Lorsqu'une requête échoue côté serveur, citez l'en-tête X-Request-Id dans votre message à support. Cela leur permet de trouver cet appel précis sans deviner. Gardez également à l'esprit que les requêtes échouées ou refusées ne sont pas facturées, donc une session de débogage pleine d'erreurs ne consomme pas votre crédit d'essai.

Un dernier point de conception. Donnez à chaque nœud une tâche étroite et un prompt court. Un graphe avec un planificateur, un rédacteur et un vérificateur, chacun avec son propre petit message système, est plus facile à tester qu'un seul nœud avec une page d'instructions, et chaque élément peut être testé seul avec un appel direct llm.invoke avant de le connecter.

Ce que coûte réellement une exécution d'essai

Le prix est de 0,15 $ par 1M de tokens d'entrée et de 0,50 $ par 1M de tokens de sortie, prélevés sur le crédit prépayé. Les requêtes échouées ou refusées ne sont pas facturées. Les graphes d'agents appellent le modèle plusieurs fois par tâche, et chaque appel renvoie la liste des messages croissante, donc les tokens d'entrée dominent.

Prenez une exécution avec six appels de modèle. Disons que chaque appel envoie 3 000 tokens en entrée et retourne 400 tokens en sortie. Cela représente 18 000 tokens d'entrée et 2 400 tokens de sortie.

• Entrée : 18 000 / 1 000 000 x $0,15 = $0,0027
• Sortie : 2 400 / 1 000 000 x $0,50 = $0,0012
• Total : $0,0039 par exécution

Le crédit d'essai de 0,50 $ divisé par 0,0039 $ donne environ 128 exécutions de cette taille, suffisantes pour construire et tester correctement un graphe. Lorsque vous le dépassez, les recharges vont de 20 $ à 500 $ en montants entiers, avec un bonus de 5 % à partir de 50 $, 10 % à partir de 100 $ et 15 % à partir de 200 $ ; la page tarification a les détails. Vous pouvez payer par carte (Visa, Mastercard, Apple Pay, Google Pay) ou avec de la crypto (USDT sur TRC20, USDC sur Base). Le crédit n'expire jamais, et les prompts ne sont pas utilisés pour l'entraînement.

La fenêtre de contexte est de 100 000 tokens pour le prompt plus la complétion, donc les longs historiques d'agents tiennent, mais vous payez pour chaque token que vous renvoyez. La réduction des anciens messages avec les utilitaires de messages de LangGraph maintient le coût et la latence à la baisse. Pour le format de requête brut derrière tout cela, consultez la documentation API.

Plus de guides

• LLM de texte vers audio : ce qu'il peut et ne peut pas faire
• API de texte sans censure pour les prompts vidéo