Punti chiave
- ChatOpenAI accetta base_url, api_key e model, quindi qualsiasi endpoint compatibile con OpenAI funziona.
- Usa l'URL base https://api.uncensoredllmhub.com/v1 e il modello uncensored.
- La chiamata di funzioni è supportata; per l'output strutturato, la modalità JSON è il metodo più sicuro.
- Rispetta i limiti: 8 richieste concorrenti su una chiave completa, quindi limita la concorrenza del tuo batch.
Installa e connetti
L'integrazione OpenAI di LangChain è un pacchetto separato dalla libreria core. Installalo con pip install langchain-openai. Ottieni una chiave dalla pagina delle chiavi API; i nuovi utenti possono richiedere $0,50 di credito di prova con un clic, senza carta.
Poi crea l'oggetto modello. Tre argomenti sono importanti: model, base_url e api_key.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredllmhub.com/v1",
api_key="YOUR_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a lighthouse cat.").content)Questa è l'intera integrazione. Tutto ciò che segue, come prompt, parser, agenti e retriever, tratta llm come qualsiasi altro modello di chat. Se preferisci le variabili d'ambiente, l'SDK OpenAI legge OPENAI_API_KEY e OPENAI_BASE_URL, il che facilita il passaggio tra gli ambienti senza toccare il codice.
Cosa supporta l'endpoint
Il servizio espone POST /v1/chat/completions, POST /v1/responses e GET /v1/models. ChatOpenAI usa le chat completions di default, che è la scelta sicura. Il modello è un modello a pesi aperti ottimizzato per rispondere senza rifiuti di contenuto per uso adulto lecito, con una finestra di contesto da 100.000 token condivisa da prompt e completamento.
Funzionalità di richiesta supportate su cui LangChain si basa: streaming su SSE con utilizzo alla fine, tool calling, modalità JSON e i parametri di campionamento temperature, top_p, stop, seed e le penalità. Non disponibili: embeddings, generazione di immagini o audio, fine-tuning. Se una catena di retrieval ha bisogno di embeddings, usa un modello di embedding diverso per quel passaggio e mantieni questo endpoint per la generazione. Le note complete sui parametri sono nella documentazione.
Un prompt, un modello e un parser
Il pattern LCEL di base instrada un prompt nel modello e poi in un parser di output. Lo streaming è gratuito con .stream().
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You are a concise editor. Reply in {tone} tone."),
("human", "Improve this sentence: {text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))
for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
print(piece, end="", flush=True)Il messaggio di sistema imposta il comportamento per ogni chiamata. Poiché la finestra di contesto è ampia, puoi anche alimentare testo di riferimento lungo tramite il template del prompt senza un separatore in molti casi. I costi di input sono $0,15 per 1M di token, quindi un documento da 20.000 token nel prompt costa 20.000 / 1.000.000 x $0,15 = $0,003 per chiamata.
Chiamata di funzioni
Il tool calling segue il formato OpenAI: passi le definizioni delle funzioni, il modello risponde con tool_calls, esegui la funzione e restituisci il risultato come messaggio con il ruolo tool. LangChain avvolge questo in bind_tools.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([add])
msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
print(call["name"], call["args"]) # run the function yourself, then send a ToolMessage backIl modello richiede la chiamata; il tuo codice la esegue. In un framework agent come LangGraph, un ciclo lo fa per te fino a quando il modello non risponde in testo normale. Mantieni le descrizioni delle funzioni brevi e i nomi degli argomenti semplici. Se il modello ignora un tool, stringi il docstring e imposta tool_choice per forzare la chiamata mentre debugghi.
Output strutturato con modalità JSON
L'endpoint supporta la modalità JSON, response_format: {"type":"json_object"}. In LangChain, richiedilo tramite with_structured_output e scegli il metodo della modalità JSON, quindi valida con un modello Pydantic.
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
class Ticket(BaseModel):
title: str
priority: str
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")
print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))Due abitudini rendono JSON affidabile. Primo, scrivi "JSON" e nomina le chiavi nel prompt, poiché la modalità JSON garantisce una sintassi valida ma non il tuo schema. Secondo, avvolgi la chiamata in un retry che cattura gli errori di convalida e invia il testo dell'errore al modello una volta. Non dipendere dalla decodifica vincolata allo schema a meno che tu non l'abbia testata con questo endpoint.
Concorrenza, retry e controllo dei costi
LangChain rende facili le chiamate parallele con .batch(), ed è lì che i limiti si fanno sentire. Una chiave completa permette 8 richieste concorrenti e 300 al minuto. Una chiave di prova ne permette 2 e 60. Passa config={"max_concurrency": 6} a batch per restare sotto il limite.
Quando il limite viene superato, l'API restituisce HTTP 429 con codice rate_limited o concurrency, e un'intestazione Retry-After: 5 in caso di sovraccarico temporaneo. ChatOpenAI ha un argomento max_retries che gestisce questi casi con backoff; impostalo a 3 o 5. Gli stream occupano uno slot fino al termine, quindi non lasciare aperti stream parzialmente letti.
Esempio di costo calcolato: un job batch di 2.000 elementi, ciascuno con 800 token di input e 150 token di output. Input: 2.000 x 800 = 1.600.000 token = 1,6 x $0,15 = $0,24. Output: 2.000 x 150 = 300.000 token = 0,3 x $0,50 = $0,15. Il job costa $0,39. Le richieste fallite o rifiutate non vengono addebitate e l'intestazione X-Balance-USD ti permette di monitorare il tuo saldo. Vedi prezzi per le ricariche, che vanno da $20 a $500 e possono essere pagate con cripto.
Agenti e memoria della conversazione
Due pattern si presentano subito dopo che la prima catena funziona. Il primo è la memoria della conversazione. I helper di memoria delle messaggi di LangChain memorizzano i turni passati e li antepone a ogni chiamata. Poiché la finestra è di 100.000 token, puoi mantenere storie lunghe, ma ricorda che ogni turno le ritrasmette. Una storia di 30.000 token per ciascuno dei 50 turni significa 1.500.000 token di input, o 1,5 x $0,15 = $0,225 per la sessione. Riassumere i turni vecchi una volta che la storia supera un limite di dimensione mantiene i costi stabili.
Il secondo è il ciclo agent. In LangGraph, un agent predefinito prende lo stesso oggetto llm più un elenco di strumenti e itera fino a quando il modello smette di richiedere strumenti. Imposta un numero massimo di passaggi in modo che un ciclo confuso non possa far salire i token di input. Registra l'intestazione di risposta X-Request-Id per qualsiasi chiamata che si comporta in modo strano, poiché è l'identificatore da citare se contatti supporto.
Risoluzione dei Problemi
- 404 su ogni chiamata. L'URL base deve terminare con
/v1e non deve includere/chat/completions. - Modello non trovato. Usa
uncensoredesattamente. LangChain non convalida i nomi dei modelli per gli endpoint personalizzati. - Avvisi di conteggio token. Alcune funzionalità di LangChain stimano i token con i tokenizer OpenAI. I conteggi possono differire leggermente dal modello reale, quindi affidati all'utilizzo restituito dall'API.
- I cicli agent lunghi diventano costosi. Ogni ciclo ritrasmette l'intera cronologia. Taglia i vecchi output degli strumenti prima che raggiungano la chiamata successiva.
Se la tua catena sembra corretta ma fallisce ancora, chiama l'endpoint con curl semplice per separare un problema di LangChain da un problema dell'account.

