DE ▾

Uncensored Model HubLangChain Open-Source-Modelle über eine unzensierte API

LangChain Open-Source-Modelle über eine unzensierte API

LangChain funktioniert mit Open-Source-Modellen über jeden OpenAI-kompatiblen Server, und eine gehostete API erspart dir, GPUs selbst zu betreiben. Hier ist die Einrichtung in Python und Node, mit Tools, einem Agent, JSON-Ausgabe, Streaming und einem Concurrency-Plan.

Aktualisiert

Glasketten, die modulare Blöcke mit einem Serverwürfel verbinden, veranschaulichen LangChain mit einer Open-Weight-Modell-API

Wichtige Punkte

  1. Verwende ChatOpenAI mit base_url, das auf https://api.uncensoredmodelhub.com/v1 gesetzt ist, und dem Modell uncensored.
  2. Tool Calling, JSON-Modus und Streaming funktionieren über die Standard-LangChain-Schnittstellen.
  3. Begrenze max_concurrency auf 8 bei einem Voll-Key, 2 bei einem Trial-Key, um 429-Fehler zu vermeiden.
  4. Die Preise betragen $0,15 pro 1 Mio. Input-Token und $0,50 pro 1 Mio. Output-Token, ohne Abonnement.

Verbinde LangChain in vier Zeilen

Wenn du LangChain Open-Source-Modelle nutzen möchtest, ohne etwas zu hosten, ist der kürzeste Weg eine OpenAI-kompatible API. Die OpenAI-Chat-Klasse von LangChain ist es egal, wer antwortet, solange der Endpunkt das gleiche Protokoll spricht. Du änderst die base_url und den Schlüssel, und der Rest deiner Chains, Prompts und Agents bleibt unverändert.

Dieser Dienst hostet ein Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und optimiert für Antworten ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene. Es ist nicht die offizielle API eines Modell-Anbieters und kein Router über Anbieter hinweg. Installiere das Paket und erstelle das Modell-Objekt:

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)

Das ist die gesamte Verbindung. Halte den Schlüssel in echten Projekten in einer Umgebungsvariable und lies ihn mit os.environ aus, statt ihn in die Datei zu schreiben. Wenn du noch keinen Schlüssel hast, zeigt die Schlüsselseite, wie du dich anmeldest und $0,50 kostenloses Testguthaben erhältst, ohne dass eine Karte benötigt wird.

Node.js und LangChain.js

Das JavaScript-Paket folgt der gleichen Idee, wobei die base_url über ein Konfigurationsobjekt übergeben wird.

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

Wenn du einen 404-Fehler oder eine HTML-Seite siehst, ist die base_url meist falsch. Sie muss mit /v1 enden. Die beiden Endpunkte im Hintergrund sind POST /v1/chat/completions und GET /v1/models, und nichts anderes wird für das Chat-Modell von LangChain benötigt.

Ist ein Open-Source-Modell in LangChain besser gehostet oder lokal?

LangChain kann auch Open-Weight-Modelle auf deiner eigenen Maschine ausführen, zum Beispiel über Ollama oder einen lokalen Server. Dieser Weg hat echte Vorteile, und es ist ehrlich, das zu sagen. Lokale Modelle haben keine Token-Gebühren, funktionieren offline und halten jedes Byte auf deiner Hardware. Der Preis ist Hardware: Du brauchst genug GPU-Speicher für das gewählte Modell, du pflegst die Laufzeit, und der Durchsatz ist durch deine Maschine begrenzt.

FrageLokaler ServerDiese gehostete API
VorabkostenHardware oder eine gemietete GPUKeine; Prepaid-Guthaben ab $20
Token-KostenKeine, aber Strom und Hardware-Verschleiß$0,15 pro 1M Input, $0,50 pro 1M Output
KontextfensterAbhängig vom verfügbaren Speicher100.000 Token
ParallelitätAbhängig von deiner Einrichtung8 bei einem Voll-Key
DatenstandortDeine MaschineGehostet; Prompts werden nicht zum Training verwendet

Ein gängiges Muster ist, gegen den gehosteten Endpunkt zu prototypen und dann anhand echter Token-Anzahlen zu entscheiden, ob eine lokale Bereitstellung sinnvoll ist. Da beide Seiten das OpenAI-Protokoll sprechen, ist das Wechseln eine einzeilige Änderung an base_url, und die von dir gebauten Chains bleiben unberührt. Die Seite zu was ein unzensiertes Modell ist erklärt, was die Feinabstimmung am Verhalten ändert.

Tools und ein einfacher Agent

Tool Calling geht über das normale OpenAI-Style-tools-Feld, und bind_tools von LangChain baut das für dich aus einer dekorierten Python-Funktion. Das Modell gibt Tool-Aufruf-Anfragen zurück, und Ergebnisse gehen als role: "tool"-Nachrichten zurück.

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)

Die Agent-Schleife ruft das Modell auf, führt das Tool bei Bedarf aus und sendet die Ausgabe zurück, bis das Modell in Klartext antwortet. Zwei Warnungen gelten. Gib jedem Tool einen Docstring, der für das Modell geschrieben ist, weil dieser Text es liest, um ein Tool auszuwählen. Und setze eine Rekursionsgrenze für Agents, damit ein verwirrter Durchlauf nicht weiter Kredit verbraucht; LangGraph akzeptiert recursion_limit in der Konfiguration.

Für direkte Kontrolle ohne Agent verwende llm.bind_tools([word_count]) und prüfe .tool_calls in der zurückgegebenen Nachricht selbst.

Strukturierte Ausgabe mit JSON-Modus

Für Extraktionsaufgaben gib den JSON-Modus-Parameter über bind weiter. Der Prompt muss dem Modell mitteilen, welche Schlüssel du willst, da JSON-Modus es nur dazu bringt, ein gültiges JSON-Objekt zu produzieren.

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)

Validiere das Ergebnis mit Pydantic oder einer einfachen Schlüsselprüfung, bevor du es nutzt. Der Modus erzwingt kein Schema, daher ist ein fehlendes Feld möglich, und ein Retry mit einem klareren Prompt behebt das meist.

Streaming und Concurrency

Streaming läuft über Server-Sent Events und funktioniert mit der Standard-stream-Methode. Die Nutzung wird am Ende des Streams gesendet.

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

Wenn du viele Elemente verarbeitest, führt batch sie parallel aus, und hier zählen die Limits. Ein Voll-Key erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Ein Trial-Key erlaubt 2 und 60. Eine gestreamte Anfrage belegt ihren Slot, bis der Stream endet. Gib einen Cap an, damit LangChain nie das überschreitet, was dein Key erlaubt:

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

Wenn du immer noch HTTP 429 siehst, sagt der Fehlercode, welches Limit du getroffen hast: rate_limited für Anfragen pro Minute, concurrency für zu viele gleichzeitig. Ein 429 mit einem Retry-After: 5-Header markiert temporäre Überlastung. ChatOpenAI hat eine max_retries-Option, die bei solchen Fehlern mit Backoff wiederholt; setze sie auf 3 oder 4 für Batch-Jobs.

Eine Retrieval-Kette ohne Embedding-Endpunkt

Diese API deckt nur Generierung ab, daher braucht eine Retrieval-Kette zwei Anbieter: einen für Embeddings und einen für den Chat-Schritt. LangChain macht das einfach, da der Vector Store und das Chat-Modell separate Objekte sind. Nutze jedes Embedding-Modell, das du magst, aus einer lokalen Bibliothek oder einem anderen Dienst, um deine Dokumente zu indizieren. Gib dann den abgerufenen Text über den Prompt an das Chat-Modell weiter.

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?"})

Hier ist top_chunks das, was dein Retriever zurückgegeben hat. Beschränke es auf die wenigen Passagen, die wichtig sind. Vier Chunks mit 300 Token fügen 1.200 Token pro Aufruf hinzu, was in Ordnung ist, aber vierzig Chunks fügen 12.000 hinzu und machen jede Anfrage zehnmal schwerer.

Fehlerbehebungs-Checkliste

  • Authentifizierungsfehler: bestätige, dass der Schlüssel in api_key steht, nicht in einem anderen Parameter, und dass keine OPENAI_API_KEY-Umgebungsvariable stillschweigend überschreibt, was du übergeben wolltest.
  • Modell nicht gefunden: die Modell-ID ist genau uncensored. Rufe GET /v1/models auf, um zu sehen, was der Server auflistet.
  • Seltsame Tool-Argumente: lies den rohen Argumenten-String, verschärfe die Tool-Beschreibung und senke die Temperatur auf etwa 0,2 für Agent-Durchläufe.
  • Tracing und Debugging: aktiviere den verbose- oder Debug-Modus lokal, um jeden ausgehenden Prompt und jede eingehende Antwort zu sehen.
  • Reproduzierbare Tests: gib seed und eine niedrige Temperatur an, wenn du Prompt-Versionen vergleichst, damit Unterschiede von deiner Änderung stammen und nicht vom Zufall.

Kosten einer LangChain-Arbeitslast

Die Abrechnung erfolgt pro Token vom Prepaid-Guthaben. Es gibt kein Abonnement, fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und Guthaben verfällt nie. Aufladungen sind beliebige ganze Beträge von $20 bis $500, per Krypto (USDT auf TRC20, USDC auf Base), mit einem Bonus von 5 % ab $50, 10 % ab $100 und 15 % ab $200. Die Preisseite enthält die Details.

Rechne ein Beispiel durch. Ein Support-Bot beantwortet 2.000 Fragen an einem Tag. Jede Anfrage sendet etwa 1.500 Token (System-Prompt, abgerufene Snippets, Frage) und gibt etwa 250 Token zurück.

  • Input: 2.000 x 1.500 = 3.000.000 Token, also 3 x $0,15 = $0,45.
  • Output: 2.000 x 250 = 500.000 Token, also 0,5 x $0,50 = $0,25.
  • Gesamt: $0,70 pro Tag für 2.000 Antworten, oder $0,00035 pro Antwort.

Retrieval-Chains sind der Ort, an dem die Kosten entgleisen können, da jeder zusätzliche abgerufene Chunk Eingabe-Token zu jeder Anfrage hinzufügt. Logge usage_metadata aus den Antworten, beobachte die durchschnittliche Prompt-Größe und reduziere die Chunk-Anzahl, bevor du skalierst. Die API-Dokumentation listet alle unterstützten Parameter auf, falls du weitergehen möchtest.

Fragen und Antworten

Welche LangChain-Klasse verwende ich für diese API?

Verwende ChatOpenAI aus langchain-openai in Python oder @langchain/openai in JavaScript. Setze das Modell auf uncensored und richte base_url auf https://api.uncensoredmodelhub.com/v1 ein.

Unterstützt es Agents und Tool Calling?

Ja. Tool Calling verwendet das OpenAI-Style-Tools-Format, daher funktionieren bind_tools und LangGraph-Agents. Überprüfe die Tool-Argumente selbst, da das Modell sie als Text zurückgibt.

Wie groß ist das Kontextfenster für LangChain-Ketten?

100.000 Token, die sich Prompt und Completion teilen. Lange Memory-Puffer und viele abgerufene Chunks verbrauchen davon einiges, also kürze die Historie in deiner Kette.

Sind Embeddings für meinen Vector Store verfügbar?

Nein. Die API ist nur Text-Chat, ohne Embeddings, Bilder, Audio oder Fine-Tuning. Verwende einen separaten Embedding-Anbieter für Retrieval und diese API für den Generierungsschritt.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten