La risposta breve: tre impostazioni su ChatOpenAI
Se hai cercato chat open ai langchain, probabilmente hai un progetto LangChain che usa già ChatOpenAI e vuoi che comunichi con un backend diverso. È una modifica di configurazione, non una riscrittura. L'API di questo sito parla il protocollo di completamento di chat OpenAI, quindi LangChain lo tratta come qualsiasi altro server in stile OpenAI.
Ti servono l'URL base, la tua chiave API e l'ID del modello uncensored. Installa prima i pacchetti:
pip install -U langchain-openai langgraphPoi crea l'oggetto modello:
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.nofilteraichat.com/v1",
api_key=os.environ["NOFILTER_API_KEY"],
temperature=0.8,
)
reply = llm.invoke("Write a two-sentence villain monologue for a heist novel.")
print(reply.content)Questa è l'intera integrazione. Ogni funzionalità di LangChain basata su ChatOpenAI ora gira sul modello uncensored: catene, retriever che chiamano il modello di chat, parser di output e agent. Se non hai ancora una chiave, la pagina API key spiega la registrazione e il credito di prova con un clic.
Tieni la chiave fuori dal codice
Inserisci la chiave in una variabile d'ambiente e leggila all'avvio. Su Linux o macOS:
export NOFILTER_API_KEY="paste-your-key-here"Crea un modulo client condiviso per il progetto, ad esempio llm.py che crea il modello una volta sola ed esporta l'oggetto. Ogni catena importa poi lo stesso oggetto e una modifica successiva di chiave, timeout o temperatura avviene in un unico punto. Questo rende anche facile mantenere una seconda istanza più fredda per i passaggi degli strumenti e una più calda per la scrittura creativa, entrambe puntate allo stesso endpoint con impostazioni diverse.
Una trappola coglie molte persone: ChatOpenAI legge anche OPENAI_API_KEY e OPENAI_API_BASE dall'ambiente. Se quelle variabili sono impostate per un altro progetto, un oggetto parzialmente configurato potrebbe inviare la tua richiesta al server sbagliato. Passare base_url e api_key esplicitamente, come sopra, rimuove l'ambiguità.
Puoi confermare la connessione senza LangChain del tutto. L'endpoint dei modelli dovrebbe restituire una singola voce:
curl https://api.nofilteraichat.com/v1/models \
-H "Authorization: Bearer $NOFILTER_API_KEY"Se questo funziona ma LangChain fallisce, il problema è nel tuo ambiente Python, non nella chiave. Se entrambi falliscono con 401, controlla la presenza di spazi o newline casuali nella chiave. La guida quickstart elenca il formato di richiesta esatto per il confronto.
Streaming e utilizzo dei token
Le interfacce utente di chat sono migliori quando i token appaiono mentre vengono generati. LangChain espone questo tramite .stream(), e il server invia chunk SSE standard quando stream: true è impostato sotto il cofano.
from langchain_openai import ChatOpenAI
import os
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.nofilteraichat.com/v1",
api_key=os.environ["NOFILTER_API_KEY"],
stream_usage=True,
)
final = None
for chunk in llm.stream("Describe a rainy harbour town in four sentences."):
print(chunk.content, end="", flush=True)
final = chunk if final is None else final + chunk
print()
print(final.usage_metadata)Con stream_usage=True l'ultimo chunk contiene i conteggi dei token di input e output, che l'API invia alla fine dello stream. Conserva questi numeri. Sono il modo più economico per vedere quanto costa realmente un agent, e li usiamo nella sezione sui costi di seguito.
Una cosa da ricordare: una richiesta in streaming occupa la sua slot di concorrenza fino al termine dello stream. Se abbandoni uno stream senza chiuderlo, quella slot rimane occupata più a lungo del previsto.
Node e TypeScript
Il pacchetto JavaScript usa un nome di opzione leggermente diverso. L'URL base va all'interno di configuration:
npm install @langchain/openai @langchain/coreimport { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.NOFILTER_API_KEY,
configuration: { baseURL: "https://api.nofilteraichat.com/v1" },
temperature: 0.8,
});
const res = await llm.invoke("Give me three names for a smuggler's ship.");
console.log(res.content);I tipi TypeScript per la risposta sono le solite classi di messaggio di LangChain, quindi il codice esistente che legge res.content o res.usage_metadata continua a funzionare. Quando esegui questo all'interno di una route del server, crea il modello una volta sola a livello di modulo piuttosto che per ogni richiesta. Questo evita di creare un nuovo client HTTP per ogni chiamata e mantiene la tua concorrenza facile da gestire.
Tutto il resto, inclusi .stream(), .bindTools() e .withStructuredOutput(), si comporta allo stesso modo che in Python. Temperature, top_p, sequenze di stop, seed e le opzioni di penalità vengono passate al modello, quindi puoi impostarle sul costruttore come faresti per qualsiasi altro backend in stile OpenAI.
Chiamata di funzioni e un piccolo agent
L'API supporta la chiamata di funzioni: i campi tools e tool_choice, lo streaming di tool_calls e i risultati delle funzioni restituiti come messaggi role: "tool". L'agent predefinito di LangGraph utilizza esattamente questo loop. Ecco un agent con una sola funzione:
import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
@tool
def roll_dice(sides: int) -> int:
"""Roll a die with the given number of sides."""
import random
return random.randint(1, sides)
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.nofilteraichat.com/v1",
api_key=os.environ["NOFILTER_API_KEY"],
)
agent = create_react_agent(llm, [roll_dice])
out = agent.invoke(
{"messages": [("user", "Roll a twenty-sided die twice and tell me the total.")]}
)
print(out["messages"][-1].content)L'uso di strumenti con modelli a pesi aperti è meno prevedibile rispetto a un flagship ospitato, quindi trattalo come qualcosa da testare. Scrivi le descrizioni degli strumenti in parole semplici, mantieni gli schemi degli argomenti piccoli e imposta temperature basso (0,2-0,4) per i passaggi dell'agent che devono produrre argomenti validi. Se una chiamata torna malformata, LangChain la segnala come chiamata di strumento non valida e un nuovo tentativo con una descrizione più chiara di solito la risolve.
Mantieni il loop dell'agent limitato. LangGraph ha un limite di ricorsione e dovresti impostarlo su un numero che puoi permetterti. Se un agent può chiamare strumenti all'infinito, un prompt difettoso può bruciare credito mentre sei lontano dalla tastiera. Un limite di 10-15 passaggi è un'impostazione predefinita sensibile per la maggior parte dei compiti e puoi passarlo nella configurazione quando invochi l'agent.
Output strutturato
La modalità JSON è disponibile tramite response_format. In LangChain, chiedi di attivarla con il metodo della modalità JSON e nomina le chiavi nel tuo prompt:
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
import os
class Character(BaseModel):
name: str
role: str
secret: str
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.nofilteraichat.com/v1",
api_key=os.environ["NOFILTER_API_KEY"],
)
structured = llm.with_structured_output(Character, method="json_mode")
print(structured.invoke(
"Return JSON with keys name, role and secret for a noir detective."
))Limiti di richieste, tentativi di ripetizione e costi
Una chiave completa permette 8 richieste concorrenti e 300 richieste al minuto. Una chiave di prova permette 2 e 60. Quando superi uno di questi limiti, l'API risponde con HTTP 429 e un codice di errore: rate_limited per le richieste al minuto, concurrency per troppe richieste simultanee. Un sovraccarico temporaneo restituisce anche 429, con un'intestazione Retry-After: 5.
LangChain ti offre due manopole per questo. max_retries sul modello riprova le chiamate fallite con backoff, e max_concurrency nella configurazione di esecuzione limita il lavoro batch parallelo:
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.nofilteraichat.com/v1",
api_key=os.environ["NOFILTER_API_KEY"],
max_retries=4,
timeout=120,
)
answers = llm.batch(
["Prompt one", "Prompt two", "Prompt three", "Prompt four"],
config={"max_concurrency": 6},
)Impostare max_concurrency a 6 su una chiave completa lascia margine per un secondo processo. Ricorda che ogni passaggio di un agent è una richiesta separata e un passaggio in streaming occupa la sua slot fino alla fine dello stream.
Quanto costa un'esecuzione dell'agente
La tariffazione è $0,15 per 1M di token di input e $0,50 per 1M di token di output. Supponiamo che un passaggio di agent invii 3.000 token di cronologia, strumenti e istruzioni, e che il modello scriva 500 token. L'input costa 3.000 × $0,15 / 1.000.000 = $0,00045. L'output costa 500 × $0,50 / 1.000.000 = $0,00025. Un passaggio costa $0,0007. Un'esecuzione di dieci passaggi costa $0,007 e 1.000 tali esecuzioni costano $7,00.
Gli agent rispediscono la loro cronologia in crescita a ogni passaggio, quindi i token di input dominano. Tagliare l'output degli strumenti vecchio è l'ottimizzazione più economica che hai. Le richieste fallite o rifiutate non vengono addebitate. I dettagli sui ricarichi e i bonus sono nella pagina dei prezzi.
Problemi comuni
- 404 su ogni chiamata. L'URL base deve terminare con
/v1e non deve includere/chat/completions. LangChain aggiunge il percorso da solo. - Modello non trovato. L'unico ID del modello è
uncensored. Nomi come gpt-4o non funzioneranno. - Errori di contesto. La finestra è di 100.000 token per prompt più completamento. Catene di retrieval lunghe possono superarla. Riassumi o taglia prima di inviare.
- Richiesta troppo grande. Il limite del corpo è 8 MB, il che conta se inserisci documenti interi in un prompt.
- Fallimento degli embedding. Questa API è solo per chat testuale. Mantieni il tuo modello di embedding su un altro provider e usa questo endpoint per la generazione.
Lo stesso schema funziona per altri framework e interfacce di chat; la guida di integrazione copre più client. Per qualsiasi cosa insolita, la pagina di supporto è il punto di partenza.
