LangChain en LangGraph zonder API-sleutel

Wat "zonder API-sleutel" realistisch kan betekenen

Zoeken naar langchain en langraph zonder api key betekent meestal een van drie dingen. Je wilt misschien niet betalen voordat je weet of de stack werkt. Je wilt misschien geen creditcard geven aan nog een leverancier. Of je hoopt een agent graph te draaien zonder enige credentials.

De derde wens kan niet worden ingelost door een gehoste service: een server die het werk voor jou doet, moet weten wie er aanroept. Wat je wel kunt krijgen is een sleutel die niets kost en geen kaart vraagt. Nieuwe gebruikers op deze site kunnen $0,50 aan trial tegoed claimen met één klik op de API key pagina na het aanmelden met Google of met een e-mail en wachtwoord. Het is één per persoon en 7 dagen geldig.

De andere route naar "geen sleutel" is een lokaal model dat wordt geserveerd door iets op je eigen machine. Dat werkt, maar jij draagt de hardware, en een laptop haalt een gehost endpoint niet lang bij voor lange agent runs. Een gehoste trial is de snelste manier om te zien of je graph logica klopt, en de code die je schrijft is identiek aan wat je later met een gefinancierde key draait.

Omdat het endpoint OpenAI-compatible is, heeft LangChain geen speciale integratie nodig. Je wijst zijn OpenAI chat class naar een andere base URL, geef het de sleutel en noem het model uncensored. Alles hieronder gaat uit van die setup.

Stap 1: haal de trial key op en stel de omgeving in

Meld je aan, open de key pagina en druk op de trial knop. Kopieer de sleutel en houd deze buiten je repository. Zet hem in een environment variable zodat hetzelfde script vandaag werkt met een trial key en later met een volledige key.

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

Voordat je een framework betrekt, controleer je de sleutel met een eenvoudig verzoek. Twee minuten hier bespaart een uur lezen van stack traces die eigenlijk authenticatiefouten zijn.

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

Een GET /v1/models call is de andere snelle check; deze zou uncensored moeten opsommen. De trial key staat 2 gelijktijdige verzoeken en 60 verzoeken per minuut toe, wat meer dan genoeg is voor het ontwikkelen van een graph, maar het is goed om te onthouden wanneer je parallelle nodes toevoegt.

Stap 2: wijs LangChain naar het endpoint

De te gebruiken class is ChatOpenAI van langchain-openai. Twee argumenten doen het werk: base_url en api_key. De modelnaam is uncensored, en de gebruikelijke sampling settings worden doorgegeven.

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)

Als dit tekst afdrukt, is de verbinding goed. Streaming werkt op dezelfde manier: itereren over llm.stream(...) en de chunks komen aan via server-sent events, met usage gerapporteerd aan het einde van de stream.

Een veelgemaakte fout is het laten staan van de OPENAI_API_KEY variabele ingesteld vanuit een oud project. LangChain zal die waarde graag naar je aangepaste base URL sturen als je vergeet om api_key door te geven. Geef de sleutel expliciet door en je verwijdert het raden.

Stap 3: een minimale LangGraph graph

LangGraph modelleert je agent als state die tussen nodes beweegt. De kleinste bruikbare graph heeft één node die het model aanroept en het antwoord toevoegt aan een berichtenlijst. MessagesState geeft je die lijst gratis.

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)

Dit is bewust eenvoudig. Het punt is dat niets in LangGraph weet of uitmaakt welke provider achter llm zit. Elke node kan een ander model object nemen, dus je kunt later een goedkope planning stap en een langere schrijf stap hun eigen instellingen geven, zoals een lagere temperature voor planning.

Stap 4: tools en een lus toevoegen

Agents worden interessant wanneer het model functies kan aanroepen. Het endpoint ondersteunt toolaanroep met tools en tool_choice, en tool results gaan terug als role: "tool" berichten. LangChain en LangGraph regelen die infrastructuur voor je.

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)

De lus is het hele idee: de agent node antwoordt, tools_condition controleert of het antwoord om een toolaanroep vroeg, de tool node voert het uit en de controle keert terug naar de agent. Wanneer een antwoord geen toolaanroep heeft, eindigt de graph.

Open-weight modellen variëren in hoe netjes hun tool argumenten zijn. Als een call terugkomt als malformed, maak de documentatiestring van de tool strakker, verlaag de temperature en houd het argument schema klein. Korte, getypeerde schema's falen minder vaak dan lange met veel optionele velden.

Rate limits, retries en parallelle takken

De plek waar agentgrafieken het vaakst struikelen is gelijktijdigheid. Een volledige key staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe; een trial key staat 2 en 60 toe. Als je graph uitwaait naar vijf parallelle nodes op een trial key, worden drie ervan afgewezen met HTTP 429 en de error code concurrency. Het overschrijden van de per minuut budget retourneert rate_limited. Tijdelijke overload geeft ook een 429, met een Retry-After: 5 header.

Drie gewoontes houden dit beheersbaar:

• Houd max_retries op 2 of 3 op ChatOpenAI zodat korte 429s worden herhaald met backoff.
• Beperk uitwaaiing tot je concurrency limit. In LangGraph kun je config={"max_concurrency": 2} doorgeven bij het aanroepen van de graph.
• Onthoud dat een gestreamd verzoek zijn slot vasthoudt tot de stream eindigt, dus een trage ontvanger houdt een slot bezet.

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

De response headers helpen bij het debuggen. X-Request-Id identificeert een call als je support erover moet vragen, en X-Balance-USD toont je resterende tegoed na elk verzoek.

Debugging checklist wanneer de graph zich vreemd gedraagt

De meeste fouten in een eerste LangGraph-project hebben niets met het model te maken. Ze komen door configuratie, en een korte checklist vangt bijna alle van ze op.

1. 401 of authenticatiefouten. De sleutel ontbreekt, is verkeerd getypt, of een oude OPENAI_API_KEY wordt gelezen in plaats daarvan. Print de eerste vier tekens van de waarde die je script daadwerkelijk gebruikt.
2. 404 of model niet gevonden. De modelnaam moet uncensored zijn. Roep GET /v1/models aan als je niet zeker bent wat het endpoint opsomt.
3. Verbindingsfouten. De base URL moet eindigen op /v1 en mag niet /chat/completions bevatten; de client voegt dat deel toe.
4. Oneindige loops. Als de agent blijft proberen een tool aan te roepen, is het resultaat misschien niet het antwoord op de vraag. Geef eenvoudige, korte strings terug en stel een recursielimiet in via de graph-configuratie, zodat een foute loop snel stopt.
5. Lege of vreemde antwoorden. Print de volledige berichtenlijst na een run. Vaak heeft een eerder knooppunt een systeembericht geschreven dat tegenstrijdig is met het latere bericht.

Als een verzoek aan de serverkant faalt, vermeld dan de X-Request-Id-header in je bericht aan support. Zo kunnen zij dat exacte verzoek vinden zonder raden. Houd er ook rekening mee dat gefaalde of geweigerde verzoeken niet worden aangerekend, dus een debugsessie vol fouten vreet je gratis proeftegoed niet op.

Nog een ontwerppunt. Geef elk knooppunt een smalle taak en een korte prompt. Een graph met een planner, een schrijver en een checker, elk met hun eigen kleine systeembericht, is makkelijker te testen dan één enkel knooppunt met een pagina aan instructies, en elk onderdeel kun je apart proberen met een directe llm.invoke-aanroep voordat je het inbedt.

Wat een trial run eigenlijk kost

Prijzen zijn $0,15 per 1M input-tokens en $0,50 per 1M output-tokens, van prepaid tegoed. Gefaalde of geweigerde verzoeken worden niet aangerekend. Agent-graphs roepen het model meerdere keren aan per taak, en elke aanroep stuurt de groeiende berichtenlijst opnieuw, dus input-tokens domineren.

Doe een run met zes modelaanroepen. Stel dat elke aanroep 3.000 tokens invoert en 400 tokens retourneert. Dat is 18.000 invoertokens en 2.400 uitvoertokens.

• Invoer: 18.000 / 1.000.000 x $0,15 = $0,0027
• Uitvoer: 2.400 / 1.000.000 x $0,50 = $0,0012
• Totaal: $0,0039 per run

De $0,50 proefversie gedeeld door $0,0039 is ongeveer 128 uitvoeringen van die grootte, genoeg om een graph goed te bouwen en te testen. Als je daaruit gegroeid bent, kun je tegoed opwaarderen van $20 tot $500 in hele bedragen, met een bonus van 5% vanaf $50, 10% vanaf $100 en 15% vanaf $200; de prijzenpagina heeft de details. Je kunt betalen met een kaart (Visa, Mastercard, Apple Pay, Google Pay) of met crypto (USDT op TRC20, USDC op Base). Credit verloopt niet, en prompts worden niet gebruikt voor training.

Het contextvenster is 100.000 tokens voor prompt plus completion, dus lange agentgeschiedenissen passen, maar je betaalt voor elke token die je opnieuw verstuurt. Het inkorten van oude berichten met LangGraph's message utilities houdt kosten en latentie laag. Voor het ruwe request-formaat achter al dit, zie de API docs.

Meer handleidingen

• Text to Audio LLM: Wat Het Kan En Niet Kan
• Uncensored Text API voor Video Prompts