NL ▾

Uncensored Model HubLangChain open-sourcemodellen via een ongecensureerde API

LangChain open-sourcemodellen via een ongecensureerde API

LangChain werkt met open sourcemodellen via elke OpenAI-compatibele server, en een gehoste API bespaart je het zelf draaien van GPUs. Hier is de setup in Python en Node, met tools, een agent, JSON-output, streaming en een concurrency-plan.

Bijgewerkt

Glazen ketenschakels die modulaire blokken verbinden met een serverkubus, illustratie van LangChain met een open-weight model API

Belangrijkste punten

  1. Gebruik ChatOpenAI met base_url ingesteld op https://api.uncensoredmodelhub.com/v1 en model uncensored.
  2. Tool calling, JSON-modus en streaming werken allemaal via de standaard LangChain-interfaces.
  3. Beperk max_concurrency tot 8 op een volledige sleutel, 2 op een proefsleutel, om 429-fouten te vermijden.
  4. Prijzen zijn $0,15 per 1M input en $0,50 per 1M output tokens, zonder abonnement.

Verbind LangChain in vier regels

Als je langchain open sourcemodellen wilt gebruiken zonder iets te hosten, is de kortste weg een OpenAI-compatibele API. De OpenAI chat-class van LangChain maakt het niet uit wie antwoordt, zolang het endpoint hetzelfde protocol spreekt. Je wijzigt de base URL en de sleutel, en de rest van je chains, prompts en agents blijven zoals ze zijn.

Deze service hostt één open-weight model, uitgevoerd door een onafhankelijke provider en afgestemd op antwoorden zonder weigeringen van inhoud, voor wettig gebruik door volwassenen. Het is niet de officiële API van een model vendor en het is geen router tussen vendors. Installeer het package en maak het model object:

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)

Dat is de hele verbinding. Houd de sleutel in een environment variable in echte projecten en lees deze met os.environ in plaats van deze in het bestand te schrijven. Als je nog geen sleutel hebt, toont de sleutelpagina hoe je je kunt aanmelden en $0,50 proeftegoed claimt, zonder kaart.

Node.js en LangChain.js

Het JavaScript package volgt hetzelfde idee, met de base URL die via een configuratieobject wordt doorgegeven.

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

Als je een 404 of een HTML-pagina in de fout ziet, is de base URL meestal verkeerd. Deze moet eindigen op /v1. De twee endpoints achter de schermen zijn POST /v1/chat/completions en GET /v1/models, en niets anders is nodig voor het chatmodel van LangChain.

Is een open source model in LangChain beter gehost of lokaal?

LangChain kan ook open modellen op je eigen machine draaien, bijvoorbeeld via Ollama of een lokale server. Die route heeft echte voordelen, en het is eerlijk om dat te zeggen. Lokale modellen kosten geen kosten per token, werken offline en houden elke byte op je hardware. De prijs is hardware: je hebt genoeg GPU-geheugen nodig voor het model dat je kiest, je onderhoudt de runtime en de throughput is beperkt door je machine.

VraagLokale serverDeze gehoste API
Voorafgaande kostenHardware of een gehuurde GPUGeen; prepaid credit vanaf $20
Kosten per tokenGeen, maar wel stroom en slijtage van hardware$0,15 per 1M in, $0,50 per 1M out
ContextvensterAfhankelijk van je beschikbare geheugen100.000 tokens
Gelijktijdige verzoekenAfhankelijk van je setup8 op een volledige sleutel
GegevenslocatieJouw machineGehost; prompts niet gebruikt voor training

Een veelvoorkomend patroon is om te prototypen tegen het gehoste endpoint, en dan aan de hand van echte tokenaantallen te beslissen of een lokale implementatie zinvol is. Omdat beide kanten het OpenAI-protocol spreken, is overschakelen een wijziging van één regel in base_url, en blijven de ketens die je hebt gebouwd onaangetast. De pagina over wat een ongecensureerd model is legt uit wat de tuning verandert aan het gedrag.

Tools en een eenvoudige agent

Function calling gaat via het normale OpenAI-stijl tools veld, en bind_tools van LangChain bouwt dat voor je vanuit een gedecoreerde Python-functie. Het model retourneert verzoeken voor toolaanroepen, en resultaten gaan terug als role: "tool" berichten.

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)

De agentlus roept het model aan, voert de tool uit wanneer dat wordt gevraagd, en stuurt de uitvoer terug totdat het model in gewone tekst antwoordt. Twee waarschuwingen zijn van toepassing. Geef elke tool een docstring geschreven voor het model, omdat die tekst het is wat het leest om een tool te kiezen. En stel een recursielimiet in voor agents zodat een verwarde run niet blijft doorgaan met het uitgeven van tegoed; LangGraph accepteert een recursion_limit in de configuratie.

Voor directe controle zonder een agent, gebruik llm.bind_tools([word_count]) en inspecteer .tool_calls op het geretourneerde bericht zelf.

Gestructureerde uitvoer met JSON-modus

Voor extractietaken, geef de JSON-modus parameter door via bind. De prompt moet het model vertellen welke sleutels je wilt, omdat JSON-modus het alleen dwingt tot het produceren van een geldig JSON-object.

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)

Valideer het resultaat met Pydantic of een simpele controle op sleutels voordat je het gebruikt. De modus dwingt geen schema af, dus een ontbrekend veld is mogelijk, en een nieuwe poging met een duidelijkere prompt lost dit meestal op.

Streaming en concurrency

Streaming draait over server-sent events en werkt met de standaard stream methode. Gebruik wordt aan het einde van de stream verstuurd.

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

Wanneer je veel items verwerkt, draait batch ze parallel, en hier zijn limits belangrijk. Een volledige sleutel staat 8 gelijktijdige requests en 300 requests per minuut toe. Een proefsleutel staat 2 en 60 toe. Een gestreamde request houdt zijn slot vast tot de stream eindigt. Geef een cap mee zodat LangChain nooit meer doet dan je sleutel toestaat:

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

Als je nog steeds HTTP 429 ziet, vertelt de error code welke limit je raakte: rate_limited voor requests per minuut, concurrency voor te veel tegelijk. Een 429 met een Retry-After: 5 header markeert tijdelijke overload. ChatOpenAI heeft een max_retries optie die retryt op zulke fouten met backoff; stel dit in op 3 of 4 voor batch jobs.

Een retrieval chain zonder embeddings endpoint

Deze API dekt alleen generatie, dus een retrieval chain heeft twee providers nodig: één voor embeddings en één voor de chat stap. LangChain maakt dat makkelijk, omdat de vector store en het chat model aparte objecten zijn. Gebruik welk embedding model je maar wilt, van een lokale library of een andere service, om je documenten te indexeren. Geef dan de opgehaalde tekst door aan het chat model via de 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?"})

Hier is top_chunks wat je retriever heeft teruggegeven. Houd het bij de paar passages die ertoe doen. Vier chunks van 300 tokens voegen 1.200 tokens per call toe, wat prima is, maar veertig chunks voegen 12.000 toe en maken elke request tien keer zwaarder.

Probleemoplossingscontrolelijst

  • Authenticatiefouten: bevestig dat de sleutel in api_key staat, niet in een andere parameter, en dat er geen OPENAI_API_KEY environment variable is die stilzwijgend overschrijft wat je wilde doorgeven.
  • Model niet gevonden: de model ID is precies uncensored. Roep GET /v1/models aan om te zien wat de server opsomt.
  • Vreemde toolargumenten: lees de ruwe argumentenstring, verscherp de toolbeschrijving en verlaag de temperatuur naar ongeveer 0,2 voor agent runs.
  • Tracing en debugging: zet LangChain's verbose of debug mode lokaal aan om elke prompt te zien dat wordt verstuurd en elk antwoord dat terugkomt.
  • Herhaalbare tests: geef seed en een lage temperatuur door als je promptversies vergelijkt, zodat verschillen komen van je wijziging en niet van toevallige sampling.

Kosten van een LangChain workload

Er wordt per token afgerekend vanaf prepaid tegoed. Er is geen abonnement, mislukte of geweigerde requests worden niet in rekening gebracht, en tegoed vervalt nooit. Top-ups zijn elk geheel bedrag van $20 tot $500, per crypto (USDT op TRC20, USDC op Base), met een 5% bonus vanaf $50, 10% vanaf $100 en 15% vanaf $200. De prijspagina heeft de details.

Werk een voorbeeld uit. Een supportbot beantwoordt 2.000 vragen in een dag. Elk verzoek verzendt ongeveer 1.500 tokens (systeemprompt, opgehaalde fragmenten, vraag) en retourneert ongeveer 250 tokens.

  • Input: 2.000 x 1.500 = 3.000.000 tokens, dus 3 x $0,15 = $0,45.
  • Output: 2.000 x 250 = 500.000 tokens, dus 0,5 x $0,50 = $0,25.
  • Totaal: $0,70 per dag voor 2.000 antwoorden, of $0,00035 elk.

Ophaalketens zijn waar kosten kunnen afwijken, omdat elk extra opgehaald fragment inputtokens toevoegt aan elke aanroep. Log usage_metadata van responsen, houd de gemiddelde promptgrootte in de gaten, en verminder het aantal fragmenten voordat je opschalt. De API-documentatie somt alle ondersteunde parameters op als je verder wilt gaan.

Vragen en antwoorden

Welke LangChain-class gebruik ik voor deze API?

Gebruik ChatOpenAI van langchain-openai in Python of @langchain/openai in JavaScript. Stel het model in op uncensored en wijs base_url naar https://api.uncensoredmodelhub.com/v1.

Wordt ondersteuning voor agents en tool calling geboden?

Ja. Tool calling gebruikt het OpenAI-style tools formaat, dus bind_tools en LangGraph agents werken. Valideer tool argumenten zelf, omdat het model ze als tekst retourneert.

Wat is het contextvenster voor LangChain chains?

100.000 tokens, gedeeld tussen prompt en completion. Lange memory buffers en veel opgehaalde chunks verbruiken het, dus kort de geschiedenis in je chain in.

Zijn embeddings beschikbaar voor mijn vector store?

Nee. De API is alleen tekstchat, zonder embeddings, afbeeldingen, audio of fine-tuning. Gebruik een aparte embedding provider voor retrieval en deze API voor de generatiestap.

Je sleutel is nog maar één formulier verwijderd

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

API-sleutel aanvragen