LangChain und LangGraph ohne API-Schlüssel

Was „ohne API-Schlüssel“ realistisch bedeuten kann

Die Suche nach langchain und langraph ohne API-Schlüssel bedeutet meist eines von drei Dingen. Du möchtest vielleicht nicht bezahlen, bevor du weißt, dass das Stack funktioniert. Du möchtest vielleicht keinem weiteren Anbieter deine Kreditkarte geben. Oder du hoffst, einen Agenten-Graphen komplett ohne Credentials auszuführen.

Der dritte Wunsch lässt sich von keinem gehosteten Dienst erfüllen: Ein Server, der die Arbeit für dich erledigt, muss wissen, wer ihn aufruft. Was du bekommen kannst, ist ein Key, der nichts kostet und keine Karte verlangt. Neue Nutzer auf dieser Seite können 0,50 $ Trial-Guthaben mit einem Klick auf der API-Schlüssel-Seite nach der Anmeldung mit Google oder E-Mail und Passwort beanspruchen. Es ist ein Key pro Person und 7 Tage gültig.

Die andere Route zu „kein Key“ ist ein lokales Modell, das von einer Software auf deinem eigenen Rechner bereitgestellt wird. Das funktioniert, aber du trägst die Hardware, und ein Laptop kann bei langen Agenten-Durchläufen einem gehosteten Endpunkt nicht lange standhalten. Ein gehostetes Trial ist der schnellere Weg, um zu prüfen, ob deine Graph-Logik stimmt, und der Code, den du schreibst, ist identisch mit dem, den du später mit einem bezahlten Key ausführst.

Da der Endpunkt OpenAI-kompatibel ist, benötigt LangChain keine spezielle Integration. Du richtest seine OpenAI-Chat-Klasse auf eine andere base URL, gibst ihr den API-Schlüssel und nennst das Modell uncensored. Alles Weitere geht von dieser Einrichtung aus.

Schritt 1: Trial-Key besorgen und Umgebung einrichten

Melde dich an, öffne die Key-Seite und drücke die Trial-Schaltfläche. Kopiere den Key und halte ihn aus deinem Repository heraus. Speichere ihn in einer Umgebungsvariable, damit dasselbe Skript heute mit einem Trial-Key und später mit einem Voll-Key funktioniert.

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

Prüfe den Key vor der Einbindung eines Frameworks mit einer einfachen Anfrage. Zwei Minuten hier sparen eine Stunde beim Lesen von Stack-Traces, die eigentlich Authentifizierungsfehler sind.

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"}]}'

Ein GET /v1/models-Aufruf ist die andere schnelle Prüfung; er sollte uncensored auflisten. Der Trial-Key erlaubt 2 parallele Anfragen und 60 Anfragen pro Minute, was für die Entwicklung eines Graphen mehr als ausreichend ist, aber beim Hinzufügen paralleler Nodes zu beachten ist.

Schritt 2: LangChain auf den Endpunkt richten

Die zu verwendende Klasse ist ChatOpenAI aus langchain-openai. Zwei Argumente erledigen die Arbeit: base_url und api_key. Der Modellname ist uncensored, und die üblichen Sampling-Einstellungen werden durchgereicht.

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)

Wenn dies Text ausgibt, ist die Verbindung gut. Streaming funktioniert auf die gleiche Weise: Iteriere über llm.stream(...) und die Chunks kommen über Server-Sent Events an, wobei die Nutzung am Ende des Streams gemeldet wird.

Ein häufiger Fehler ist, die Variable OPENAI_API_KEY aus einem alten Projekt noch gesetzt zu lassen. LangChain sendet diesen Wert gerne an deine benutzerdefinierte Base URL, wenn du vergisst, api_key explizit zu übergeben. Gib den Schlüssel explizit an, dann entfällt das Raten.

Schritt 3: ein minimaler LangGraph-Graph

LangGraph modelliert deinen Agenten als Zustand, der zwischen Nodes wandert. Der kleinste nützliche Graph hat einen Node, der das Modell aufruft und die Antwort an eine Nachrichtenliste anhängt. MessagesState gibt dir diese Liste kostenlos.

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)

Dies ist bewusst einfach gehalten. Der Punkt ist, dass LangGraph nicht weiß oder interessiert, welcher Anbieter hinter llm sitzt. Jeder Node kann ein anderes Modell-Objekt verwenden, sodass du später einem günstigen Planungsschritt und einem längeren Schreibschritt ihre eigenen Einstellungen geben kannst, z. B. eine niedrigere Temperatur für die Planung.

Schritt 4: Tools und eine Schleife hinzufügen

Agenten werden interessant, wenn das Modell Funktionen aufrufen kann. Der Endpunkt unterstützt Tool Calling mit tools und tool_choice, und Tool-Ergebnisse gehen als role: "tool"-Nachrichten zurück. LangChain und LangGraph übernehmen diese Infrastruktur für dich.

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)

Die Schleife ist die ganze Idee: Der Agent-Node antwortet, tools_condition prüft, ob die Antwort ein Tool angefordert hat, der Tool-Node führt es aus, und die Steuerung kehrt zum Agenten zurück. Wenn eine Antwort kein Tool Calling enthält, endet der Graph.

Open-Weight-Modelle variieren darin, wie ordentlich ihre Tool-Argumente sind. Wenn ein Aufruf fehlerhaft zurückkommt, verschärfe das Docstring des Tools, senke die Temperatur und halte das Argument-Schema klein. Kurze, typisierte Schemas schlagen seltener fehl als lange mit vielen optionalen Feldern.

Ratenlimits, Retries und parallele Zweige

Der Ort, an dem Agenten-Graphen am häufigsten scheitern, ist die Concurrency. Ein Voll-Key erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute; ein Trial-Key erlaubt 2 und 60. Wenn dein Graph in fünf parallele Nodes auf einem Trial-Key ausläuft, werden drei von ihnen mit HTTP 429 abgelehnt und der Fehlercode concurrency zurückgegeben. Das Überschreiten des pro Minute geltenden Budgets liefert rate_limited. Temporäre Überlastung gibt ebenfalls eine 429 mit einem Retry-After: 5-Header.

Drei Gewohnheiten halten dies im Griff:

• Halte max_retries auf 2 oder 3 auf ChatOpenAI, damit kurze 429-Fehler mit Backoff wiederholt werden.
• Begrenze Fan-Out an deinem Parallelitäts-Limit. In LangGraph kannst du config={"max_concurrency": 2} übergeben, wenn du den Graphen aufrufst.
• Denke daran, dass eine gestreamte Anfrage ihren Slot hält, bis das Streaming endet, sodass ein langsamer Verbraucher einen Slot belegt hält.

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

Die Response-Header helfen beim Debugging. X-Request-Id identifiziert einen Aufruf, wenn du Support wegen ihm kontaktieren musst, und X-Balance-USD zeigt dein verbleibendes Guthaben nach jeder Anfrage an.

Debugging-Checkliste bei fehlerhaftem Graphen

Die meisten Fehler in einem ersten LangGraph-Projekt betreffen nicht das Modell. Sie stammen aus der Konfiguration, und eine kurze Checkliste fängt fast alle davon ab.

1. 401 oder Authentifizierungsfehler. Der Schlüssel fehlt, wurde falsch getippt oder ein alter OPENAI_API_KEY wird gelesen. Gib die ersten vier Zeichen des Werts aus, den dein Skript tatsächlich verwendet.
2. 404 oder Modell nicht gefunden. Der Modellname muss uncensored sein. Rufe GET /v1/models auf, wenn du unsicher bist, was der Endpunkt auflistet.
3. Verbindungsfehler. Die base URL muss mit /v1 enden und darf nicht /chat/completions enthalten; der Client fügt diesen Teil hinzu.
4. Endlosschleifen. Wenn der Agent ein Tool immer wieder aufruft, beantwortet der Rückgabewert des Tools die Frage vielleicht nicht. Gib einfache, kurze Strings zurück und setze ein Rekursionslimit über die Graph-Konfiguration, damit eine fehlerhafte Schleife frühzeitig stoppt.
5. Leere oder seltsame Antworten. Gib die vollständige Nachrichtenliste nach einem Durchlauf aus. Oft hat ein früherer Node eine Systemnachricht geschrieben, die der späteren widerspricht.

Wenn eine Anfrage auf Serverseite fehlschlägt, zitiere den X-Request-Id-Header in deiner Nachricht an Support. Das ermöglicht es ihnen, diese genaue Anfrage ohne Unsicherheit zu finden. Beachte außerdem, dass fehlgeschlagene oder abgelehnte Anfragen nicht berechnet werden, sodass eine Debugging-Sitzung voller Fehler dein Testguthaben nicht aufbraucht.

Ein weiterer Designpunkt. Gib jedem Node eine schmale Aufgabe und einen kurzen Prompt. Ein Graph mit einem Planer, einem Schreiber und einem Prüfer, jeder mit seiner eigenen kleinen Systemnachricht, ist einfacher zu testen als ein einzelner Node mit einer Seite Anweisungen, und jedes Stück kann einzeln mit einem direkten llm.invoke-Aufruf getestet werden, bevor du es einbindest.

Was ein Trial-Durchlauf tatsächlich kostet

Die Preise betragen 0,15 $ pro 1M Input-Token und 0,50 $ pro 1M Output-Token, vom Prepaid-Guthaben. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet. Agenten-Graphen rufen das Modell mehrmals pro Aufgabe auf, und jeder Aufruf sendet die wachsende Nachrichtenliste erneut, daher dominieren Input-Token.

Führe eine Runde mit sechs Modellaufrufen durch. Nehmen wir an, jeder Aufruf sendet 3.000 Token ein und gibt 400 Token zurück. Das sind 18.000 Input-Token und 2.400 Output-Token.

• Input: 18.000 / 1.000.000 × $0,15 = $0,0027
• Output: 2.400 / 1.000.000 × $0,50 = $0,0012
• Gesamt: $0,0039 pro Runde

Das $0,50-Testguthaben teilt durch $0,0039 ergibt etwa 128 Runden dieser Größe, genug, um einen Graphen richtig aufzubauen und zu testen. Wenn du das Guthaben aufgebraucht hast, kannst du es mit Aufladungen von $20 bis $500 in ganzen Beträgen auffüllen. Ab $50 gibt es einen Bonus von 5 %, ab $100 von 10 % und ab $200 von 15 %. Die Details findest du auf der Preisseite. Du kannst mit Karte (Visa, Mastercard, Apple Pay, Google Pay) oder mit Krypto (USDT auf TRC20, USDC auf Base) bezahlen. Das Guthaben verfällt nie, und Prompts werden nicht zum Training verwendet.

Das Kontextfenster umfasst 100.000 Token für Prompt und Completion, sodass lange Agenten-Verläufe passen, aber du zahlst für jeden Token, den du erneut sendest. Das Kürzen alter Nachrichten mit LangGraphs Nachrichten-Utilities hält Kosten und Latenz niedrig. Für das rohe Anfrageformat hinter allem, was hier passiert, sieh dir die API-Dokumentation an.

Weitere Anleitungen

• Text to Audio LLM: Was es kann und was es nicht kann
• Unzensierte Text-API für Video-Prompts