LangChain e LangGraph senza chiave API

Cosa può significare realisticamente "senza chiave API"

La ricerca di langchain e langraph senza api key di solito significa una di tre cose. Potresti voler evitare di pagare prima di sapere se lo stack funziona. Potresti non voler dare una carta di credito a un altro fornitore. O potresti sperare di eseguire un grafico degli agenti senza nessuna credenziale.

La terza richiesta non può essere soddisfatta da alcun servizio in hosting: un server che esegue il lavoro per te deve sapere chi lo sta chiamando. Ciò che puoi ottenere è una chiave che non costa nulla e non richiede carta. I nuovi utenti di questo sito possono richiedere $0,50 di credito di prova con un clic sulla pagina della chiave API dopo essersi registrati con Google o con un'email e una password. È una per persona e valida per 7 giorni.

L'altra strada verso la "nessuna chiave" è un modello locale servito da qualcosa sulla tua macchina. Questo funziona, ma ti occupi dell'hardware e un portatile non reggerà il confronto con un endpoint in hosting per esecuzioni di agenti lunghe. Una prova in hosting è il modo più veloce per scoprire se la logica del tuo grafico è solida e il codice che scrivi è identico a quello che eseguirai in seguito con una chiave finanziata.

Poiché l'endpoint è compatibile con OpenAI, LangChain non richiede un'integrazione speciale. Punti la sua classe chat OpenAI a un URL base diverso, gli dai la chiave e nomini il modello uncensored. Tutto quanto segue presuppone questa configurazione.

Fase 1: ottieni la chiave di prova e configura l'ambiente

Registrati, apri la pagina delle chiavi e premi il pulsante di prova. Copia la chiave e tienila fuori dal tuo repository. Inseriscila in una variabile d'ambiente in modo che lo stesso script funzioni con una chiave di prova oggi e con una chiave completa in seguito.

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

Prima di coinvolgere qualsiasi framework, verifica la chiave con una richiesta semplice. Due minuti qui risparmiano un'ora di lettura di stack trace che sono in realtà errori di autenticazione.

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

Una chiamata GET /v1/models è l'altro controllo rapido; dovrebbe elencare uncensored. La chiave di prova consente 2 richieste concorrenti e 60 richieste al minuto, il che è più che sufficiente per sviluppare un grafico ma vale la pena ricordarlo quando aggiungi nodi paralleli.

Fase 2: punta LangChain all'endpoint

La classe da usare è ChatOpenAI da langchain-openai. Due argomenti fanno il lavoro: base_url e api_key. Il nome del modello è uncensored, e le impostazioni di campionamento usuali vengono passate.

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)

Se questo stampa testo, la connessione è buona. Lo streaming funziona allo stesso modo: itera su llm.stream(...) e i chunk arrivano tramite server-sent events, con l'utilizzo segnalato alla fine dello stream.

Un errore comune è lasciare la variabile OPENAI_API_KEY impostata da un vecchio progetto. LangChain invierà felicemente quel valore al tuo URL base personalizzato se dimentichi di passare api_key. Passa la chiave esplicitamente e rimuovi l'indovinamento.

Fase 3: un grafico LangGraph minimo

LangGraph modella il tuo agente come stato che si muove tra i nodi. Il grafico utile più piccolo ha un nodo che chiama il modello e aggiunge la risposta a un elenco di messaggi. MessagesState ti dà quell'elenco gratuitamente.

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)

Questo è deliberatamente semplice. Il punto è che nulla in LangGraph sa o gli importa di quale provider si trovi dietro llm. Qualsiasi nodo può assumere un oggetto modello diverso, quindi puoi in seguito dare a un passaggio di pianificazione economico e a un passaggio di scrittura più lungo le loro impostazioni, come una temperatura più bassa per la pianificazione.

Fase 4: aggiungi strumenti e un ciclo

Gli agenti diventano interessanti quando il modello può chiamare funzioni. L'endpoint supporta la chiamata di strumenti con tools e tool_choice, e i risultati degli strumenti tornano come messaggi role: "tool". LangChain e LangGraph gestiscono quella infrastruttura per te.

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)

Il ciclo è l'idea principale: il nodo agente risponde, tools_condition controlla se la risposta ha richiesto uno strumento, il nodo strumento lo esegue e il controllo torna all'agente. Quando una risposta non ha una chiamata di strumento, il grafico termina.

I modelli a pesi aperti variano per quanto siano ordinati i loro argomenti di strumento. Se una chiamata torna malformata, stringi il docstring dello strumento, abbassa la temperatura e mantieni lo schema degli argomenti piccolo. Gli schemi brevi e tipizzati falliscono meno spesso di quelli lunghi con molti campi opzionali.

Limiti di velocità, tentativi e rami paralleli

Il punto in cui i grafici degli agenti si bloccano più spesso è la concorrenza. Una chiave completa consente 8 richieste concorrenti e 300 richieste al minuto; una chiave di prova ne consente 2 e 60. Se il tuo grafico si espande in cinque nodi paralleli su una chiave di prova, tre di essi verranno rifiutati con HTTP 429 e il codice di errore concurrency. Superare il budget per minuto restituisce rate_limited. Anche il sovraccarico temporaneo dà un 429, con un'intestazione Retry-After: 5.

Tre abitudini mantengono questo gestibile:

• Mantieni max_retries a 2 o 3 su ChatOpenAI in modo che i brevi 429 vengano ritentati con backoff.
• Limita l'espansione al tuo limite di concorrenza. In LangGraph puoi passare config={"max_concurrency": 2} quando invochi il grafico.
• Ricorda che una richiesta in streaming mantiene il suo slot fino alla fine dello stream, quindi un consumatore lento mantiene uno slot occupato.

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

Le intestazioni di risposta aiutano con il debug. X-Request-Id identifica una chiamata se devi chiedere supporto a riguardo, e X-Balance-USD mostra il tuo credito residuo dopo ogni richiesta.

Lista di controllo per il debug quando il grafico si comporta male

La maggior parte dei fallimenti in un primo progetto LangGraph non riguarda il modello. Derivano dalla configurazione e una breve lista di controllo ne cattura quasi tutti.

1. 401 o errori di autenticazione. La chiave è mancante, digitata male o viene letta una vecchia OPENAI_API_KEY. Stampa i primi quattro caratteri del valore che il tuo script sta effettivamente usando.
2. 404 o modello non trovato. Il nome del modello deve essere uncensored. Chiama GET /v1/models se non sei sicuro di cosa elenchi l'endpoint.
3. Errori di connessione. L'URL base deve terminare con /v1 e non deve includere /chat/completions; il client aggiunge quella parte.
4. Cicli infiniti. Se l'agente continua a chiamare uno strumento, il valore di ritorno dello strumento potrebbe non rispondere alla domanda. Restituisci stringhe semplici e brevi e imposta un limite di ricorsione attraverso la configurazione del grafico in modo che un ciclo errato si fermi presto.
5. Risposte vuote o strane. Stampa l'elenco completo dei messaggi dopo un'esecuzione. Spesso un nodo precedente ha scritto un messaggio di sistema che contraddice quello successivo.

Quando una richiesta fallisce lato server, cita l'intestazione X-Request-Id nel tuo messaggio a support. Questo permette loro di trovare quella chiamata esatta senza indovinamenti. Tieni presente anche che le richieste fallite o rifiutate non vengono addebitate, quindi una sessione di debug piena di errori non consuma il tuo credito di prova.

Un altro punto di progettazione. Assegna a ogni nodo un compito specifico e un prompt breve. Un grafico con un pianificatore, un scrittore e un controllore, ciascuno con il proprio piccolo messaggio di sistema, è più facile da testare rispetto a un singolo nodo con una pagina di istruzioni e ogni pezzo può essere provato da solo con una chiamata diretta llm.invoke prima di collegarlo.

Quanto costa realmente un'esecuzione di prova

I prezzi sono $0,15 per 1M di token di input e $0,50 per 1M di token di output, prelevati dal credito prepagato. Le richieste fallite o rifiutate non vengono addebitate. I grafi degli agenti chiamano il modello più volte per attività e ogni chiamata reinvia l'elenco dei messaggi in crescita, quindi i token di input dominano.

Fai un test con sei chiamate al modello. Supponi che ogni chiamata invii 3.000 token in input e restituisca 400 token in output. Si tratta di 18.000 token di input e 2.400 token di output.

• Input: 18.000 / 1.000.000 x $0,15 = $0,0027
• Output: 2.400 / 1.000.000 x $0,50 = $0,0012
• Totale: $0.0039 per esecuzione

Il credito di prova da $0,50 diviso per $0,0039 fa circa 128 test di questa dimensione, sufficienti per costruire e testare un grafo in modo adeguato. Quando lo superi, i ricarichi partono da $20 fino a $500 in importi interi, con un bonus del 5% da $50, del 10% da $100 e del 15% da $200; la pagina dei prezzi ha i dettagli. Puoi pagare con carta (Visa, Mastercard, Apple Pay, Google Pay) o con cripto (USDT su TRC20, USDC su Base). Il credito non scade mai e i prompt non vengono utilizzati per l'addestramento.

La finestra di contesto è di 100.000 token per prompt più completamento, quindi le cronologie lunghe degli agent si adattano, ma paghi ogni token che invii di nuovo. Tagliare i messaggi vecchi con le utilità per i messaggi di LangGraph mantiene bassi costi e latenza. Per il formato della richiesta grezza alla base di tutto questo, consulta la documentazione API.

Altre guide

• LLM da testo ad audio: cosa può e non può fare
• API di testo senza censura per prompt video