NL ▾

openaiapiproxy.comLangChain OpenAI Base URL: gebruik een aangepaste LLM API

LangChain OpenAI Base URL: gebruik een aangepaste LLM API

De langchain openai base url is een constructorargument voor ChatOpenAI. Stel dit in op https://api.openaiapiproxy.com/v1, geef je sleutel door en gebruik de modelnaam uncensored; elke chain en agent die een chatmodel accepteert, draait hierop.

Bijgewerkt

Een keten van gloeiende links die eindigt in één heldere bol, een representatie van een LangChain-pijplijn verbonden met een aangepast model

Belangrijkste punten

  • Gebruik in Python ChatOpenAI(base_url=..., api_key=..., model="uncensored"). Gebruik in JavaScript configuration.baseURL.
  • Prompts, chains, streaming, tool binding en JSON-modus blijven werken via de standaardinterfaces.
  • Embeddings worden niet aangeboden, dus OpenAIEmbeddings moet naar een andere service verwijzen.
  • Gebruik max_concurrency 8 op een volledige sleutel en laat retries 429-responses afhandelen.

De wijziging van twee regels

Wanneer je zoekt naar de langchain openai base url, is het antwoord kort. De chatklasse van LangChain voor OpenAI wrap de OpenAI SDK, en die SDK accepteert een aangepaste base URL. Wijs deze naar deze service en niets anders in je chain hoeft te veranderen. Installeer eerst de pakketten met 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)

Dat is de volledige integratie. De dienst is OpenAI-compatible, maar het is een apart product: één open-weight model, gerund door een onafhankelijke provider, zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik. Het is niet de officiële API van OpenAI of een andere leverancier. Gebruik de API-sleutelpagina om een sleutel te krijgen; nieuwe accounts kunnen met één klik $0,50 proeftegoed claimen, zonder kaart.

Waarom dit werkt: ChatOpenAI bouwt standaard chat completion requests en stuurt ze naar het opgegeven adres. De service antwoordt met de standaard responsvorm, dus de message objects, callbacks en parsers van LangChain gedragen zich zoals bij elke andere provider. Je houdt dezelfde abstracties aan, en alleen de bestemming verandert. Omdat de bestemming een ander model is, moet je je prompts opnieuw testen. Een prompt die is geschreven om een restrictief model tot samenwerking te bewegen, is hier misschien onnodig, en kortere instructies werken vaak beter.

Omgevingsvariabelen of expliciete argumenten

Je kunt hetzelfde configureren via de omgeving, wat handig is voor deployments. De OpenAI SDK leest OPENAI_BASE_URL en OPENAI_API_KEY. Oudere LangChain-documentatie gebruikte OPENAI_API_BASE voor hetzelfde doel. Omdat namen tussen versies zijn verschoven, is de veiligste gewoonte om base_url en api_key expliciet door te geven en je eigen variabele te lezen.

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,
)

Een echt voordeel van expliciete argumenten: als je project ook een andere provider voor andere taken gebruikt, kan een losse globale variabele dat verkeer niet naar de verkeerde plaats leiden. Twee ChatOpenAI objecten met verschillende base-URLs leven gelukkig in hetzelfde proces.

Dezelfde instelling in LangChain.js

In het JavaScript-pakket gaat de base URL in een configuration-object dat aan de onderliggende SDK wordt doorgegeven.

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);

Het hoofdlettergebruik is de val: Python gebruikt base_url, de JavaScript SDK gebruikt baseURL.

Een prompt, een model en een parser

Zodra het chatmodel is gebouwd, werkt de LangChain expression language zoals gebruikelijk. Deze chain zet een onderwerp om in een korte scène en retourneert een platte string.

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)

Streaming is afhankelijk van de server-sent events van de service, die aankomen terwijl het model ze genereert. Een gestreamde call houdt één concurrency slot vast tot het klaar is.

De | operator composeert runnables, dus dezelfde chain kan later een retriever, een tweede model call of een output parser krijgen zonder de eerdere stappen aan te raken. Als je een prompt-template tussen providers verplaatst, houd de template dan in een bestand zodat je deze apart van de endpoint-instellingen kunt versiebeheren.

Tool calling en JSON-uitvoer

LangChain zet Python-functies om in tool schemas met de @tool decorator en stuurt ze door via de standaard tools parameter. De service ondersteunt tools, tool_choice en gestreamde tool_calls, dus bind_tools werkt.

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"]))

Voor JSON-modus bind je de response format en noem je JSON in je instructies:

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))

Zelfs met JSON-modus, wikkel parsing in foutafhandeling. Wat de provider ook is, slecht gevormde output gebeurt af en toe, en een enkele retry met de parsefout erbij lost dit meestal op.

Chatgeschiedenis en lange documenten

LangChain chatmodellen nemen een lijst van messages, en de geschiedenis is aan jou om te beheren. De berichtklassen maken de rollen expliciet, wat duidelijker is dan tuples zodra een prompt meerdere delen heeft.

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)

Het contextvenster is 100.000 tokens, prompt en completion samen. Dat is ruimte voor lange chatgeschiedenissen, een personageblad en meerdere pagina's referentietekst in één call. Dit betekent niet dat je het altijd moet vullen. Input tokens worden gefactureerd tegen $0,15 per 1M, dus een prompt van 60.000 tokens kost 60.000 / 1.000.000 x $0,15 = $0,009 per call voordat het model een woord schrijft. Een retrieval stap die alleen de relevante drie pagina's stuurt is goedkoper en levert vaak betere antwoorden op.

Wanneer een prompt is samengesteld uit veel opgehaalde tekst, onthoud dan de 8 MB-limiet voor de requestbody. Dit ligt ver boven wat het tokenvenster toelaat voor normale tekst, dus je raakt meestal eerst de tokenlimiet, maar geplakte data met lange ononderbroken strings kan zich anders gedragen.

Rate limits, batches en agents

LangChain maakt parallel werk eenvoudig, wat precies is hoe je per ongeluk limieten raakt. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. Een proefsleutel staat 2 en 60 toe. Gebruik het config argument om parallelisme in batches te beperken.

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)

Als je HTTP 429 ziet, zegt de error code waarom: rate_limited voor requests per minuut, concurrency voor te veel in één keer. Bij tijdelijke overbelasting bevat de respons Retry-After: 5. De retry logica in de underlying SDK handelt het meeste af, maar agents die uitwijken naar veel parallelle tool calls kunnen een proefsleutel nog steeds verzadigen, dus verlaag max_concurrency daar naar 2.

Agents loop: elke stap stuurt de groeiende conversatie terug als input, dus input tokens lopen sneller op dan output tokens. Bij $0,15 per 1M input en $0,50 per 1M output kost een agent run die in totaal 60.000 input tokens stuurt en 6.000 output tokens produceert 60.000 / 1.000.000 x $0,15 + 6.000 / 1.000.000 x $0,50 = $0,009 + $0,003 = $0,012. De prijspagina toont top-up maten.

Wat niet meegaat

  • Embeddings. Er is geen embeddings endpoint. Als je retrieval chain bouwt op OpenAIEmbeddings, gebruik dan een andere embedding bron voor dat deel en houd alleen het chat model hier.
  • Afbeeldingen en audio. De service is alleen tekst.
  • Model switching. Er is één model, uncensored. Een dropdown van vendor model namen zal niet overeenkomen.
  • Token telling op naam. Bibliotheken die tokenaantallen raden op basis van de modelnaam, kunnen terugvallen op een benadering. Voor echte getallen, lees usage_metadata op de response message.

Het contextvenster is 100.000 tokens voor prompt en completion samen, wat ruim is voor lange chatgeschiedenissen en document stuffing. Controleer de docs voor de volledige lijst van parameters, en onthoud dat het model geen wettelijke volwassen inhoud weigert, dus voeg je eigen filters toe aan elke publieke chain. De harde regel is geen seksuele inhoud met minderjarigen.

Foutopsporing bij een chain die zich vreemd gedraagt

Wanneer een chain vreemde output geeft, ontdek wat er daadwerkelijk over de wire ging voordat je de prompt verandert. Drie tools helpen, in volgorde van inspanning.

  1. Print de response metadata. De message die wordt geretourneerd door invoke bevat response_metadata en usage_metadata. Je kunt de finish reason en de token counts controleren zonder extra setup.
  2. Zet debug logging aan. set_debug(True) van langchain_core.globals printt elke prompt en respons in een keten. Gebruik dit alleen in ontwikkeling, omdat het de volledige prompts print.
  3. Herhaal de aanroep met curl. Kopieer de weergegeven berichten uit de debug output in een verzoek naar https://api.openaiapiproxy.com/v1/chat/completions. Als curl hetzelfde gedrag vertoont, zit het probleem in je prompt. Als het verschilt, zit het probleem in de keten.

Typische symptomen en waar je moet kijken: een foutmelding niet gevonden betekent meestal dat de base URL een verdubbelde /v1 heeft of deze mist. Een bericht over een onbekend model betekent dat de naam niet uncensored is. Lege tool call lijsten betekenen vaak dat de prompt niet duidelijk maakte dat de tool gebruikt moet worden, wat een duidelijkere tool beschrijving oplost. En een agent die vastloopt kan gewoon in de wachtrij staan achter zijn eigen gelijktijdige verzoeken op een proefsleutel, dus verlaag de concurrency.

Bewaar een notitie van de verzoek-ID-header (X-Request-Id) bij fouten. Als het probleem aan de servicekant zit, legt de ondersteuningspagina uit hoe je het kunt melden, en die ID versnelt het proces.

Vragen en antwoorden

Wat is de modelnaam die je in LangChain moet gebruiken?

Gebruik uncensored. Het is het enige model ID, en GET /v1/models retourneert dit.

Neemt ChatOpenAI of OpenAI de base URL?

Gebruik ChatOpenAI van langchain-openai voor chatvoltooiingen. Het neemt base_url in Python en configuration.baseURL in JavaScript.

Kan ik OpenAIEmbeddings met deze endpoint gebruiken?

Nee. Embeddings worden niet aangeboden, dus wijs de embeddings class naar een andere service.

Waarom krijg ik HTTP 429 in een batch?

Je bent 8 gelijktijdige verzoeken of 300 verzoeken per minuut op een volledige sleutel overschreden, of 2 en 60 op een proefsleutel. Stel max_concurrency in en vertrouw op retries.

Je sleutel is nog maar één stap verwijderd

Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.

API-sleutel aanvragen