IT ▾

openaiapiproxy.comLangChain URL di base OpenAI: usa un'API LLM personalizzata

LangChain URL di base OpenAI: usa un'API LLM personalizzata

La base URL di langchain openai è un argomento del costruttore di ChatOpenAI. Impostalo a https://api.openaiapiproxy.com/v1, passa la tua chiave e usa il nome del modello uncensored, e ogni catena e agente che accetta un modello chat lo utilizzerà.

Aggiornato

Una catena di link luminosi che termina in una sfera brillante, che rappresenta una pipeline LangChain collegata a un modello personalizzato

Punti chiave

  • In Python usa ChatOpenAI(base_url=..., api_key=..., model="uncensored"). In JavaScript usa configuration.baseURL.
  • Prompt, catene, streaming, tool binding e modalità JSON continuano a funzionare attraverso le interfacce standard.
  • Le embeddings non sono offerte, quindi OpenAIEmbeddings deve puntare a un servizio diverso.
  • Usa max_concurrency 8 con una chiave completa e lascia che i retry gestiscano le risposte 429.

La modifica in due righe

Quando cerchi l'URL di base OpenAI per langchain, la risposta è breve. La classe chat OpenAI di LangChain avvolge l'SDK OpenAI, e quell'SDK accetta un URL di base personalizzato. Indirizzalo a questo servizio e nient'altro nella tua catena dovrà cambiare. Installa prima i pacchetti con pip install langchain-openai langchain-core.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.openaiapiproxy.com/v1",
    api_key="YOUR_KEY",
    temperature=0.8,
)

print(llm.invoke("Describe a rainy harbor town in two sentences.").content)

È tutta qui l'integrazione. Il servizio è compatibile con OpenAI, ma è un prodotto separato: un modello a pesi aperti, gestito da un provider indipendente, senza rifiuti di contenuti per l'uso adulto lecito. Non è l'API ufficiale di OpenAI o di qualsiasi altro fornitore. Per ottenere una chiave, usa la pagina chiave API; i nuovi account possono richiedere un credito di prova da $0,50 con un solo clic, senza carta.

Perché funziona: ChatOpenAI costruisce richieste standard di chat completion e le invia all'indirizzo che gli è stato dato. Il servizio risponde con la forma di risposta standard, quindi gli oggetti messaggio, i callback e i parser di LangChain si comportano come fanno contro qualsiasi altro provider. Mantieni le stesse astrazioni e cambia solo la destinazione. Poiché la destinazione è un modello diverso, dovresti ritestare i tuoi prompt. Un prompt scritto per indurre un modello restrittivo a collaborare potrebbe non essere necessario qui, e istruzioni più brevi spesso funzionano meglio.

Variabili d'ambiente o argomenti espliciti

Puoi configurare la stessa cosa tramite le variabili d'ambiente, utile per i deploy. L'SDK OpenAI legge OPENAI_BASE_URL e OPENAI_API_KEY. Le vecchie documentazioni di LangChain usavano OPENAI_API_BASE per lo stesso scopo. Poiché i nomi sono cambiati tra le versioni, la prassi più sicura è passare esplicitamente base_url e api_key e leggere la tua variabile.

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.openaiapiproxy.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    max_retries=3,
    timeout=120,
)

Un vero vantaggio degli argomenti espliciti: se il tuo progetto usa anche un altro provider per altri compiti, una variabile globale dispersiva non può reindirizzare quel traffico nel posto sbagliato. Due oggetti ChatOpenAI con URL di base diversi convivono felicemente nello stesso processo.

La stessa impostazione in LangChain.js

Nel pacchetto JavaScript l'URL di base va dentro un oggetto configuration che viene passato all'SDK sottostante.

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

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

const res = await llm.invoke("Give me three names for a haunted ship.");
console.log(res.content);

La maiuscola è la solita trappola: Python usa base_url, l'SDK JavaScript usa baseURL.

Un prompt, un modello e un parser

Una volta costruito il modello chat, il linguaggio delle espressioni LangChain funziona come al solito. Questa catena trasforma un argomento in una breve scena e restituisce una stringa semplice.

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

llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

prompt = ChatPromptTemplate.from_messages([
    ("system", "You write short scenes for an adult fiction platform."),
    ("human", "Write a scene about: {topic}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"topic": "two smugglers meeting at a closed customs office"}))

for piece in chain.stream({"topic": "a stormy night at a mountain inn"}):
    print(piece, end="", flush=True)

Lo streaming si basa sugli eventi server-sent del servizio, che arrivano mentre il modello li genera. Una chiamata in streaming occupa uno slot di concorrenza fino al termine.

L'operatore | compone i runnables, quindi la stessa catena può in seguito guadagnare un retriever, una seconda chiamata al modello o un output parser senza toccare i passaggi precedenti. Se sposti un modello di prompt tra i provider, mantieni il template in un file così puoi versionarlo separatamente dalle impostazioni dell'endpoint.

Chiamata di funzioni e output JSON

LangChain trasforma le funzioni Python in schemi di tool con il decoratore @tool e le invia tramite il parametro standard tools. Il servizio supporta tools, tool_choice e tool_calls in streaming, quindi bind_tools funziona.

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def lookup_character(name: str) -> str:
    """Return the notes for a character in the story bible."""
    notes = {"Mara": "A ferry pilot with a fear of deep water."}
    return notes.get(name, "No notes.")

llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([lookup_character])

reply = llm_tools.invoke("What do we know about Mara?")
for call in reply.tool_calls:
    print(call["name"], call["args"])
    print(lookup_character.invoke(call["args"]))

Per la modalità JSON, associa il formato di risposta e menziona JSON nelle tue istruzioni:

import json
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke("Return a JSON object with keys title and summary for a pirate novel.")
print(json.loads(msg.content))

Anche con la modalità JSON, avvolgi il parsing in un blocco di gestione degli errori. Indipendentemente dal provider, output malformati si verificano occasionalmente e un singolo tentativo con l'errore di parsing allegato di solito lo risolve.

Cronologia chat e documenti lunghi

I modelli chat LangChain accettano una lista di messaggi, e la cronologia è tua da gestire. Le classi messaggio rendono i ruoli espliciti, il che è più chiaro delle tuple una volta che un prompt ha diverse parti.

from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

messages = [
    SystemMessage(content="You are the narrator of a slow-burn mystery."),
    HumanMessage(content="Open with the detective arriving in town."),
]
first = llm.invoke(messages)
messages.append(AIMessage(content=first.content))
messages.append(HumanMessage(content="Now introduce the suspicious innkeeper."))
second = llm.invoke(messages)
print(second.content)
print(second.usage_metadata)

La finestra di contesto è di 100.000 token, prompt e completion insieme. Questo lascia spazio per lunghe cronologie di chat, un foglio personaggio e diverse pagine di testo di riferimento in una singola chiamata. Non significa che tu debba riempirlo sempre. I token di input sono fatturati a $0,15 per 1M, quindi un prompt da 60.000 token costa 60.000 / 1.000.000 x $0,15 = $0,009 per chiamata prima che il modello scriva una parola. Un passaggio di recupero che invia solo le tre pagine pertinenti è più economico e spesso fornisce risposte migliori.

Quando un prompt è costruito da molto testo recuperato, ricorda il limite di 8 MB sul corpo della richiesta. È ben al di sopra di ciò che la finestra dei token permette per testo normale, quindi di solito raggiungerai prima il limite dei token, ma i dati incollati con lunghe stringhe continue possono comportarsi diversamente.

Limiti di richieste, batch e agenti

LangChain rende facile il lavoro parallelo, che è esattamente il modo in cui si superano i limiti per errore. Una chiave standard permette 8 richieste concorrenti e 300 al minuto. Una chiave di prova ne permette 2 e 60. Usa l'argomento di configurazione per limitare il parallelismo nei batch.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)

titles = llm.batch(
    [f"Suggest a title for episode {i} of a space western." for i in range(1, 25)],
    config={"max_concurrency": 8},
)
for t in titles:
    print(t.content)

Se vedi HTTP 429, il codice di errore spiega il motivo: rate_limited per le richieste al minuto, concurrency per troppe contemporaneamente. In caso di sovraccarico temporaneo, la risposta include Retry-After: 5. La logica di retry nell'SDK sottostante gestisce la maggior parte di questi casi, ma gli agenti che si espandono in molte tool_calls parallele possono comunque saturare una chiave di prova, quindi riduci max_concurrency a 2 lì.

Loop degli agenti: ogni passaggio invia la conversazione in crescita come input, quindi i token di input si accumulano più velocemente di quelli di output. A $0,15 per 1M di input e $0,50 per 1M di output, un'esecuzione di un agente che invia 60.000 token di input in totale e produce 6.000 token di output costa 60.000 / 1.000.000 x $0,15 + 6.000 / 1.000.000 x $0,50 = $0,009 + $0,003 = $0,012. La pagina prezzi mostra gli importi di ricarica.

Cosa non si mantiene

  • Embeddings. Non c'è un endpoint embeddings. Se la tua catena di retrieval si basa su OpenAIEmbeddings, usa un'altra fonte di embedding per quella parte e mantieni solo il modello chat qui.
  • Immagini e audio. Il servizio è solo testo.
  • Cambio modello. C'è un solo modello, uncensored. Un menu a tendina con nomi di modelli dei vendor non corrisponderà.
  • Conteggio token per nome. Le librerie che indovinano i conteggi dei token dal nome del modello possono ricorrere a un'approssimazione. Per numeri reali, leggi usage_metadata sul messaggio di risposta.

La finestra di contesto è di 100.000 token per prompt e completion insieme, il che è generoso per lunghe cronologie di chat e document stuffing. Controlla la pagina docs per l'elenco completo dei parametri e ricorda che il modello non rifiuta contenuti adulti leciti, quindi aggiungi i tuoi filtri a qualsiasi catena esposta al pubblico. La regola ferrea è nessun contenuto sessuale che coinvolga minorenni.

Debug di una catena che si comporta male

Quando una catena dà output strani, scopri cosa è effettivamente passato sul filo prima di cambiare il prompt. Tre strumenti aiutano, in ordine di sforzo.

  1. Stampa i metadati della risposta. Il messaggio restituito da invoke trasporta response_metadata e usage_metadata. Puoi controllare il motivo di fine e i conteggi dei token senza alcuna configurazione aggiuntiva.
  2. Attiva il logging di debug. set_debug(True) da langchain_core.globals stampa ogni prompt e risposta in una catena. Usalo solo in sviluppo, perché stampa i prompt completi.
  3. Ripeti la chiamata con curl. Copia i messaggi renderizzati dall'output di debug in una richiesta a https://api.openaiapiproxy.com/v1/chat/completions. Se curl si comporta allo stesso modo, il problema è nel tuo prompt. Se è diverso, il problema è nella catena.

Sintomi tipici e dove cercare: un errore not-found di solito significa che la base URL ha un /v1 duplicato o lo manca. Un messaggio su un modello sconosciuto significa che il nome non è uncensored. Liste di tool call vuote significano spesso che il prompt non ha chiarito che il tool dovrebbe essere usato, cosa che una descrizione del tool più chiara risolve. E un agente che va in stallo potrebbe semplicemente essere in coda dietro le sue stesse chiamate parallele su una chiave di prova, quindi riduci la concorrenza.

Prendi nota dell'intestazione request ID (X-Request-Id) dai fallimenti. Se un problema è lato servizio, la pagina di supporto spiega come segnalarlo e quell'ID accelera le cose.

Domande e risposte

Qual è il nome del modello da usare in LangChain?

Usa uncensored. È l'unico ID del modello, e GET /v1/models lo restituisce.

È ChatOpenAI o OpenAI a ricevere l'URL di base?

Usa ChatOpenAI da langchain-openai per le completions di chat. Usa base_url in Python e configuration.baseURL in JavaScript.

Posso usare OpenAIEmbeddings con questo endpoint?

No. Le embedding non sono offerte, quindi punta la classe embedding a un servizio diverso.

Perché ottengo HTTP 429 in un batch?

Hai superato 8 richieste concorrenti o 300 richieste al minuto con una chiave standard, oppure 2 e 60 con una chiave di prova. Imposta max_concurrency e affidati ai tentativi.

La tua chiave è a un modulo web di distanza

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

Ottieni la chiave API