Wichtige Punkte
- Verwende in Python ChatOpenAI(base_url=..., api_key=..., model="uncensored"). Verwende in JavaScript configuration.baseURL.
- Prompts, Chains, Streaming, Tool-Binding und JSON-Modus funktionieren weiterhin über die Standard-Schnittstellen.
- Embeddings werden nicht angeboten, daher muss OpenAIEmbeddings auf einen anderen Dienst verweisen.
- Verwende max_concurrency 8 auf einem vollständigen Schlüssel und lass Retries 429-Responses behandeln.
Die Änderung in zwei Zeilen
Wenn du nach der langchain openai base url suchst, ist die Antwort kurz. LangChain's OpenAI-Chatklasse wrappt das OpenAI SDK, und dieses SDK akzeptiert eine benutzerdefinierte Base URL. Weise sie diesem Dienst zu, und nichts anderes in deiner Kette muss geändert werden. Installiere die Pakete zuerst mit 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)Das ist die gesamte Integration. Der Dienst ist OpenAI-kompatibel, aber ein separates Produkt: ein Open-Weight-Modell, betrieben von einem unabhängigen Anbieter, ohne Inhaltsablehnungen für die legale Erwachsenen-Nutzung. Es ist nicht die offizielle API von OpenAI oder einem anderen Anbieter. Um einen Schlüssel zu erhalten, nutze die API-Schlüssel-Seite; neue Konten können mit einem Klick ein $0.50 Testguthaben beanspruchen, ohne Karte.
Warum das funktioniert: ChatOpenAI erstellt Standard-Chat-Vervollständigungsanfragen und sendet sie an die zugewiesene Adresse. Der Dienst antwortet mit der Standard-Antwortstruktur, sodass LangChain's Nachrichtenobjekte, Callbacks und Parser wie bei jedem anderen Anbieter funktionieren. Du behältst dieselben Abstraktionen, und nur das Ziel ändert sich. Da das Ziel ein anderes Modell ist, solltest du deine Prompts erneut testen. Ein Prompt, der ein restriktives Modell zur Kooperation überreden muss, ist hier möglicherweise unnötig, und kürzere Anweisungen funktionieren oft besser.
Umgebungsvariablen oder explizite Argumente
Du kannst dasselbe über die Umgebung konfigurieren, was für Bereitstellungen praktisch ist. Das OpenAI SDK liest OPENAI_BASE_URL und OPENAI_API_KEY. Ältere LangChain-Dokumentationen verwendeten OPENAI_API_BASE für denselben Zweck. Da sich die Namen zwischen Versionen verschoben haben, ist es am sichersten, base_url und api_key explizit zu übergeben und deine eigene Variable zu lesen.
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,
)Ein echter Vorteil expliziter Argumente: Wenn dein Projekt auch einen anderen Anbieter für andere Aufgaben verwendet, kann eine verirrte globale Variable diesen Verkehr nicht an die falsche Stelle umleiten. Zwei ChatOpenAI-Objekte mit verschiedenen Base URLs leben glücklich im selben Prozess.
Die gleiche Einstellung in LangChain.js
Im JavaScript-Paket geht die Base URL in ein configuration-Objekt, das an das zugrunde liegende SDK übergeben wird.
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);Die Großschreibung ist die übliche Falle: Python verwendet base_url, das JavaScript SDK verwendet baseURL.
Ein Prompt, ein Modell und ein Parser
Sobald das Chat-Modell erstellt ist, funktioniert die LangChain Expression Language wie üblich. Diese Kette wandelt ein Thema in eine kurze Szene um und gibt einen einfachen String zurück.
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 basiert auf den Server-Sent Events des Dienstes, die eintreffen, während das Modell generiert. Eine gestreamte Anfrage belegt einen parallelen Anfrage-Slot, bis sie abgeschlossen ist.
Der |-Operator komponiert ausführbare Objekte, sodass die gleiche Kette später einen Sucher, einen zweiten Modellaufruf oder einen Auswerter erhalten kann, ohne die früheren Schritte zu berühren. Wenn du eine Prompt-Vorlage zwischen Anbietern verschiebst, behalte die Vorlage in einer Datei, damit du sie separat von den Endpunkteinstellungen versionieren kannst.
Function Calling und JSON-Ausgabe
LangChain wandelt Python-Funktionen mit dem @tool-Decorator in Tool-Schemata um und sendet sie über den Standard-tools-Parameter. Der Dienst unterstützt tools, tool_choice und gestreamte tool_calls, also funktioniert bind_tools.
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"]))Für den JSON-Modus binde das Antwortformat und erwähne JSON in deinen Anweisungen:
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))Auch im JSON-Modus solltest du das Parsing in eine Fehlerbehandlung einbetten. Egal welcher Anbieter, fehlerhafte Ausgaben passieren gelegentlich, und ein einzelner Retry mit dem Parse-Fehler behebt das meist.
Chat-Verlauf und lange Dokumente
LangChain-Chat-Modelle nehmen eine Liste von Nachrichten entgegen, und der Verlauf liegt in deiner Verantwortung. Die Nachrichtenklassen machen die Rollen explizit, was klarer ist als Tuples, sobald ein Prompt mehrere Teile hat.
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)Das Kontextfenster umfasst 100.000 Token für Prompt und Completion zusammen. Das ist Platz für lange Chat-Verläufe, ein Charakterbogen und mehrere Seiten Referenztext in einer Anfrage. Das bedeutet nicht, dass du es immer füllen solltest. Input-Token werden mit $0,15 pro 1 Mio. berechnet, also kostet ein 60.000-Token-Prompt 60.000 / 1.000.000 x $0,15 = $0,009 pro Anfrage, bevor das Modell ein Wort schreibt. Ein Retrieval-Schritt, der nur die relevanten drei Seiten sendet, ist günstiger und liefert oft bessere Antworten.
Wenn ein Prompt aus viel abgerufenem Text besteht, erinnere dich an die 8-MB-Grenze für den Request Body. Sie liegt weit über dem, was das Token-Fenster für normalen Text erlaubt, also wirst du normalerweise zuerst das Token-Limit erreichen, aber eingefügte Daten mit langen ununterbrochenen Strings können sich anders verhalten.
Ratenlimits, Batches und Agents
LangChain macht parallele Arbeit einfach, was genau der Weg ist, wie du Grenzen versehentlich überschreitest. Ein Voll-Key erlaubt 8 parallele Anfragen und 300 pro Minute. Ein Trial-Key erlaubt 2 und 60. Verwende das config-Argument, um die Parallelität in Batches zu begrenzen.
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)Wenn du HTTP 429 siehst, sagt der Fehlercode den Grund: rate_limited für Anfragen pro Minute, concurrency für zu viele gleichzeitig. Bei temporärer Überlastung enthält die Antwort Retry-After: 5. Die Retry-Logik im zugrunde liegenden SDK behandelt die meisten Fälle, aber Agents, die viele parallele Tool-Aufrufe ausfächern, können einen Trial-Key immer noch sättigen, also senke max_concurrency dort auf 2.
Agenten-Schleife: Jeder Schritt sendet die wachsende Konversation als Eingabe zurück, sodass Eingabe-Token schneller addiert werden als Ausgabe-Token. Bei $0,15 pro 1M Eingabe und $0,50 pro 1M Ausgabe kostet eine Agenten-Ausführung, die insgesamt 60.000 Eingabe-Token sendet und 6.000 Ausgabe-Token erzeugt, 60.000 / 1.000.000 x $0,15 + 6.000 / 1.000.000 x $0,50 = $0,009 + $0,003 = $0,012. Die Preisseite zeigt Aufladungsgrößen.
Was nicht übernommen wird
- Embeddings. Es gibt keinen Embedding-Endpunkt. Wenn deine Retrieval-Chain auf
OpenAIEmbeddingsbasiert, verwende für diesen Teil eine andere Embedding-Quelle und behalte nur das Chat-Modell hier. - Bilder und Audio. Der Dienst ist nur Text.
- Modellwechsel. Es gibt nur ein Modell,
uncensored. Eine Dropdown-Liste von Anbieter-Modellnamen wird nicht übereinstimmen. - Token-Zählung nach Name. Bibliotheken, die Token-Anzahlen aus dem Modellnamen schätzen, fallen möglicherweise auf eine Näherung zurück. Für echte Zahlen lies
usage_metadatain der Antwortnachricht.
Das Kontextfenster umfasst 100.000 Token für Prompt und Vervollständigung zusammen, was großzügig für lange Chat-Verläufe und Dokument-Stuffing ist. Prüfe die Dokumentation für die vollständige Liste der Parameter und bedenke, dass das Modell legale Erwachseneninhalte nicht ablehnt, also füge deine eigenen Filter zu jeder öffentlich zugänglichen Kette hinzu. Die harte Regel ist: keine sexuellen Inhalte mit Minderjährigen.
Debuggen einer fehlerhaften Chain
Wenn eine Chain seltsame Ausgaben liefert, finde heraus, was tatsächlich über die Leitung ging, bevor du den Prompt änderst. Drei Tools helfen, in der Reihenfolge des Aufwands.
- Drucke die Antwortmetadaten. Die von
invokezurückgegebene Nachricht enthältresponse_metadataundusage_metadata. Du kannst den Finish-Grund und die Token-Anzahlen ohne zusätzliche Einrichtung überprüfen. - Aktiviere Debug-Logging.
set_debug(True)auslangchain_core.globalsdruckt jeden Prompt und jede Antwort in einer Chain. Verwende es nur in der Entwicklung, da es die vollständigen Prompts druckt. - Wiederhole den Aufruf mit curl. Kopiere die gerenderten Nachrichten aus dem Debug-Output in eine Anfrage an
https://api.openaiapiproxy.com/v1/chat/completions. Wenn curl sich gleich verhält, liegt das Problem in deinem Prompt. Wenn es anders ist, liegt das Problem in der Chain.
Typische Symptome und wo du suchen solltest: Ein Not-Found-Fehler bedeutet normalerweise, dass die Base URL ein verdoppeltes /v1 hat oder es fehlt. Eine Meldung über ein unbekanntes Modell bedeutet, dass der Name nicht uncensored ist. Leere Tool-Calls-Listen bedeuten oft, dass der Prompt nicht klar machte, dass das Tool verwendet werden soll, was durch eine klarere Tool-Beschreibung behoben wird. Und ein Agent, der im Leerlauf hängt, könnte einfach hinter seinen eigenen parallelen Aufrufen auf einem Trial-Key in der Warteschlange liegen, also senke die Anzahl paralleler Aufrufe.
Behalte eine Notiz vom Request-ID-Header (X-Request-Id) bei Fehlern im Kopf. Wenn ein Problem auf Diensteseite liegt, erklärt die Support-Seite, wie du es melden kannst, und diese ID beschleunigt den Prozess.
