IT ▾

Uncensored Model HubModelli open source LangChain tramite un'API senza censura

Modelli open source LangChain tramite un'API senza censura

LangChain funziona con modelli open source tramite qualsiasi server compatibile con OpenAI e un'API in hosting ti risparmia di gestire le GPU da solo. Ecco la configurazione in Python e Node, con strumenti, un agent, output JSON, streaming e un piano di concorrenza.

Aggiornato

Anelli di catena di vetro che collegano blocchi modulari a un cubo del server, illustrazione di LangChain con un'API di modello a pesi aperti

Punti chiave

  1. Usa ChatOpenAI con base_url impostato su https://api.uncensoredmodelhub.com/v1 e modello uncensored.
  2. Tool calling, modalità JSON e streaming funzionano tutti tramite le interfacce standard di LangChain.
  3. Imposta max_concurrency a 8 su una chiave completa, 2 su una chiave di prova, per evitare errori 429.
  4. I prezzi sono $0,15 per 1M di token in input e $0,50 per 1M di token in output, senza abbonamento.

Connetti LangChain in quattro righe

Se vuoi usare i modelli open source di LangChain senza ospitare nulla, la strada più breve è un'API compatibile con OpenAI. La classe chat OpenAI di LangChain non si preoccupa di chi risponde, purché l'endpoint parli lo stesso protocollo. Cambi il base URL e la chiave, e il resto delle tue catene, prompt e agent rimane invariato.

Questo servizio ospita un modello a pesi aperti, gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti di contenuti per uso adulto legale. Non è l'API ufficiale di alcun vendor di modelli e non è un router tra vendor. Installa il pacchetto e crea l'oggetto modello:

pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.uncensoredmodelhub.com/v1",
    api_key="YOUR_API_KEY",
    temperature=0.7,
)

print(llm.invoke("Give me three names for a fantasy tavern.").content)

Questa è l'intera connessione. Mantieni la chiave in una variabile d'ambiente nei progetti reali e leggila con os.environ invece di scriverla nel file. Se non hai ancora una chiave, la pagina delle chiavi mostra come registrarti e richiedere $0,50 di credito di prova, senza bisogno di carta.

Node.js e LangChain.js

Il pacchetto JavaScript segue la stessa idea, con il base URL passato tramite un oggetto di configurazione.

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.API_KEY,
  temperature: 0.7,
  configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});

const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);

Se vedi un 404 o una pagina HTML nell'errore, il base URL è solitamente errato. Deve terminare con /v1. I due endpoint sottostanti sono POST /v1/chat/completions e GET /v1/models, e non serve nient'altro per il modello chat di LangChain.

Un modello open source in LangChain è meglio in hosting o locale?

LangChain può anche eseguire modelli a pesi aperti sulla tua macchina, ad esempio tramite Ollama o un server locale. Questa strada ha dei vantaggi reali ed è onesto dirlo. I modelli locali non hanno costi per token, funzionano offline e mantengono ogni byte sul tuo hardware. Il prezzo è l'hardware: hai bisogno di abbastanza memoria GPU per il modello che scegli, mantieni il runtime e il throughput è limitato dalla tua macchina.

DomandaServer localeQuesta API ospitata
Costo inizialeHardware o GPU in affittoNessuno; credito prepagato da $20
Costo per tokenNessuno, ma consumo energetico e usura dell'hardware$0,15 per 1M in input, $0,50 per 1M in output
Finestra di contestoDipende dalla memoria disponibile100.000 token
ConcorrenzaDipende dalla tua configurazione8 su una chiave completa
Posizione dei datiLa tua macchinaGestito; i prompt non sono usati per il training

Un pattern comune è fare il prototipo contro l'endpoint gestito, poi decidere con i conteggi reali dei token se un deployment locale ha senso. Poiché entrambi i lati parlano il protocollo OpenAI, il passaggio è una modifica di una riga a base_url, e le catene che hai costruito restano intatte. La pagina su cosa sia un modello senza censura spiega cosa cambiano le modifiche di tuning sul comportamento.

Strumenti e un semplice agente

La chiamata di strumenti passa attraverso il campo tools standard stile OpenAI, e bind_tools di LangChain lo costruisce per te da una funzione Python decorata. Il modello restituisce richieste di chiamata di strumenti, e i risultati tornano come messaggi role: "tool".

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

@tool
def word_count(text: str) -> int:
    '''Count the words in a piece of text.'''
    return len(text.split())

agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)

Il ciclo dell'agente chiama il modello, esegue lo strumento quando richiesto e invia l'output indietro finché il modello non risponde in testo normale. Si applicano due precauzioni. Fornisci a ogni strumento una docstring scritto per il modello, perché quel testo è ciò che legge per scegliere uno strumento. E imposta un limite di ricorsione sugli agenti così un'esecuzione confusa non può continuare a spendere credito; LangGraph accetta un recursion_limit nella configurazione.

Per un controllo diretto senza un agente, usa llm.bind_tools([word_count]) e ispeziona .tool_calls sul messaggio restituito tu stesso.

Output strutturato con modalità JSON

Per lavori di estrazione, passa il parametro della modalità JSON tramite bind. Il prompt deve dire al modello quali chiavi vuoi, poiché la modalità JSON lo spinge solo a produrre un oggetto JSON valido.

import json
from langchain_core.prompts import ChatPromptTemplate

json_llm = llm.bind(response_format={"type": "json_object"})

prompt = ChatPromptTemplate.from_messages([
    ("system", "Return a JSON object with keys title, genre and summary."),
    ("human", "{idea}"),
])

chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)

Convalida il risultato con Pydantic o un semplice controllo della chiave prima di usarlo. La modalità non impone uno schema, quindi un campo mancante è possibile, e un nuovo tentativo con un prompt più chiaro di solito lo risolve.

Streaming e concorrenza

Lo streaming avviene su server-sent events e funziona con il metodo standard stream. L'utilizzo viene inviato alla fine del flusso.

for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
    print(chunk.content, end="", flush=True)

Quando elabori molti elementi, batch li esegue in parallelo, ed è qui che i limiti contano. Una chiave completa permette 8 richieste concorrenti e 300 richieste al minuto. Una chiave di prova permette 2 e 60. Una richiesta in streaming tiene occupato il suo slot fino alla fine dello streaming. Passa un limite così LangChain non supererà mai ciò che la tua chiave permette:

prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})

Se vedi ancora HTTP 429, il codice errore ti dice quale limite hai raggiunto: rate_limited per richieste al minuto, concurrency per troppe contemporanee. Un 429 con un header Retry-After: 5 indica sovraccarico temporaneo. ChatOpenAI ha un'opzione max_retries che ritenta su tali errori con backoff; impostala a 3 o 4 per i lavori batch.

Una catena di recupero senza un endpoint per gli embeddings

Questa API copre solo la generazione, quindi una catena di recupero ha bisogno di due provider: uno per gli embeddings e uno per il passaggio di chat. LangChain rende questo facile, perché il vector store e il modello di chat sono oggetti separati. Usa qualsiasi modello di embedding che preferisci, da una libreria locale o un altro servizio, per indicizzare i tuoi documenti. Poi passa il testo recuperato al modello di chat attraverso il prompt.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
    ("human", "{question}"),
])

chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})

Qui top_chunks è qualsiasi cosa abbia restituito il tuo retriever. Limitalo ai pochi passaggi che contano. Quattro chunk da 300 token aggiungono 1.200 token per chiamata, il che va bene, ma quaranta chunk aggiungono 12.000 e rendono ogni richiesta dieci volte più pesante.

Lista di controllo per la risoluzione dei problemi

  • Errori di autenticazione: conferma che la chiave è in api_key, non in un parametro diverso, e che nessuna variabile d'ambiente OPENAI_API_KEY stia sovrascrivendo silenziosamente ciò che intendevi passare.
  • Modello non trovato: l'ID del modello è esattamente uncensored. Chiama GET /v1/models per vedere cosa elenca il server.
  • Argomenti di strumento strani: leggi la stringa degli argomenti grezzi, stringi la descrizione dello strumento e abbassa la temperatura a circa 0,2 per le esecuzioni dell'agente.
  • Tracing e debugging: attiva la modalità verbose o debug di LangChain localmente per vedere ogni prompt inviato e ogni risposta ricevuta.
  • Test ripetibili: passa seed e una temperatura bassa quando confronti le versioni dei prompt, così le differenze derivano dalla tua modifica e non dalla fortuna del campionamento.

Costo di un carico di lavoro LangChain

La fatturazione è per token dal credito prepagato. Non c'è abbonamento, le richieste fallite o rifiutate non vengono addebitate e il credito non scade mai. Le ricariche sono qualsiasi importo intero da $20 a $500, con cripto (USDT su TRC20, USDC su Base), con un bonus del 5% da $50, 10% da $100 e 15% da $200. La pagina dei prezzi ha i dettagli.

Facciamo un esempio di calcolo. Un bot di supporto risponde a 2.000 domande in un giorno. Ogni richiesta invia circa 1.500 token (prompt di sistema, snippet recuperati, domanda) e restituisce circa 250 token.

  • Input: 2.000 x 1.500 = 3.000.000 token, quindi 3 x $0,15 = $0,45.
  • Output: 2.000 x 250 = 500.000 token, quindi 0,5 x $0,50 = $0,25.
  • Totale: $0,70 al giorno per 2.000 risposte, o $0,00035 ciascuna.

Le catene di recupero sono dove i costi possono deviare, perché ogni chunk recuperato in più aggiunge token di input a ogni chiamata. Registra usage_metadata dalle risposte, osserva la dimensione media del prompt e riduci il conteggio degli chunk prima di scalare. La documentazione API elenca ogni parametro supportato se vuoi andare oltre.

Domande e risposte

Quale classe LangChain uso per questa API?

Usa ChatOpenAI da langchain-openai in Python o @langchain/openai in JavaScript. Imposta il modello a uncensored e punta base_url a https://api.uncensoredmodelhub.com/v1.

Supporta agenti e chiamata di strumenti?

Sì. La chiamata di strumenti usa il formato degli strumenti in stile OpenAI, quindi bind_tools e gli agenti LangGraph funzionano. Convalida tu stesso gli argomenti degli strumenti, poiché il modello li restituisce come testo.

Qual è la finestra di contesto per le catene LangChain?

100.000 token, condivisi tra prompt e completamento. Buffer di memoria lunghi e molti chunk recuperati li consumano, quindi riduci la cronologia nella tua catena.

Gli embedding sono disponibili per il mio vector store?

No. L'API è solo chat testuale, senza embedding, immagini, audio o fine-tuning. Usa un provider di embedding separato per il recupero e questa API per il passaggio di generazione.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.

Ottieni la chiave API