NL ▾

Begin met proeftegoed

E-mail en wachtwoord, de sleutel staat meteen op het scherm.

https://api.uncensoredllmhub.com/v1

LLM API met LangChain: een aangepast endpoint koppelen

Voor een LLM API LangChain-setup heb je alleen ChatOpenAI, een basis-URL, een sleutel en een model-ID nodig. Deze pagina toont chains, streaming, tool calling en gestructureerde uitvoer tegen dit OpenAI-compatible endpoint, met code die je kunt kopiëren.

Bijgewerkt

Glazen kettingkoppelingen verbonden met een serverblok, illustrerend LangChain chains die een aangepast LLM-endpoint aanroepen
Serverrek en weegschaal met munten naast een gloeiende cloud, die self-hosting vergelijkt met een API

Belangrijkste punten

  • ChatOpenAI neemt base_url, api_key en model, dus elk OpenAI-compatible endpoint werkt.
  • Gebruik basis-URL https://api.uncensoredllmhub.com/v1 en model uncensored.
  • Tool calling wordt ondersteund; voor gestructureerde uitvoer is JSON-modus de veiligste methode.
  • Respecteer limieten: 8 gelijktijdige verzoeken op een volledige sleutel, dus beperk je batch-concurrentie.

Installeren en verbinden

LangChain's OpenAI-integratie is een apart pakket van de core-bibliotheek. Installeer het met pip install langchain-openai. Haal een sleutel op van de API key page; nieuwe gebruikers kunnen daar met één klik $0,50 aan gratis proeftegoed claimen, zonder kaart.

Maak vervolgens het modelobject aan. Drie argumenten zijn belangrijk: model, base_url en api_key.

from langchain_openai import ChatOpenAI

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

print(llm.invoke("Give me three names for a lighthouse cat.").content)

Dat is de hele integratie. Alles downstream, zoals prompts, parsers, agents en retrievers, behandelt llm als elk ander chatmodel. Als je de voorkeur geeft aan omgevingsvariabelen, leest de OpenAI SDK OPENAI_API_KEY en OPENAI_BASE_URL, wat het makkelijk maakt om tussen omgevingen te schakelen zonder code aan te passen.

Wat de endpoint ondersteunt

De service exposeert POST /v1/chat/completions, POST /v1/responses en GET /v1/models. ChatOpenAI gebruikt chat-completies standaard, wat de veilige keuze is. Het model is een open-weight model getuned om zonder content-refusals te antwoorden voor wettelijk volwassen gebruik, met een contextvenster van 100.000 tokens gedeeld door prompt en completion.

Ondersteunde requestfuncties waar LangChain op leunt: streaming over SSE met usage aan het einde, tool calling, JSON-modus, en de samplingparameters temperature, top_p, stop, seed en de penalties. Niet beschikbaar: embeddings, image- of audio-generatie, fine-tuning. Als een retrieval chain embeddings nodig heeft, gebruik dan een ander embeddingmodel voor die stap en houd dit endpoint aan voor generatie. Volledige parameteropmerkingen staan in de docs.

Een prompt, een model en een parser

Het basis LCEL-patroon pipe een prompt naar het model en dan naar een output parser. Streaming komt er gratis bij met .stream().

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

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a concise editor. Reply in {tone} tone."),
    ("human", "Improve this sentence: {text}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))

for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
    print(piece, end="", flush=True)

Het system message bepaalt het gedrag voor elke call. Omdat het contextvenster groot is, kun je ook lange referentietekst via de prompt template voeren zonder splitter in veel gevallen. Invoerkosten zijn $0,15 per 1M tokens, dus een document van 20.000 tokens in de prompt kost 20.000 / 1.000.000 x $0,15 = $0,003 per call.

Function calling

Tool calling volgt het OpenAI-formaat: je stuurt functie-definities, het model antwoordt met tool_calls, je voert de functie uit en retourneert het resultaat als een bericht met de tool role. LangChain wikkelt dit in bind_tools.

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b

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

msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
    print(call["name"], call["args"])   # run the function yourself, then send a ToolMessage back

Het model vraagt om de call; jouw code voert hem uit. In een agent framework zoals LangGraph doet een lus dit voor je totdat het model in platte tekst antwoordt. Houd toolbeschrijvingen kort en argumentnamen eenvoudig. Als het model een tool negeert, maak de docstring strakker en stel tool_choice in om de call af te dwingen tijdens het debuggen.

Gestructureerde uitvoer met JSON-modus

Het endpoint ondersteunt JSON-modus, response_format: {"type":"json_object"}. Vraag er in LangChain om via with_structured_output en kies de JSON-modus methode, valideren dan met een Pydantic-model.

from pydantic import BaseModel
from langchain_openai import ChatOpenAI

class Ticket(BaseModel):
    title: str
    priority: str

llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")

print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))

Twee gewoontes maken JSON betrouwbaar. Eerst, zeg "JSON" en noem de keys in de prompt, aangezien JSON-modus geldige syntax garandeert maar niet jouw schema. Tweed, wikkel de call in een retry die validatiefouten vangt en de fouttekst één keer terugstuurt naar het model. Verlaat je niet op schema-constrained decoding tenzij je het hebt getest met dit endpoint.

Concurrentie, retries en kostenbeheersing

LangChain maakt parallelle calls makkelijk met .batch(), en daar bijten de limieten. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. Een proefsleutel staat 2 en 60 toe. Stel config={"max_concurrency": 6} in op batch zodat je onder de cap blijft.

Wanneer de limiet wordt overschreden, retourneert de API HTTP 429 met code rate_limited of concurrency, en een Retry-After: 5 header bij tijdelijke overbelasting. ChatOpenAI heeft een max_retries argument dat deze afhandelt met backoff; stel dit in op 3 tot 5. Streams bezetten een slot tot ze klaar zijn, dus laat geen half-gelezen streams open staan.

Voorbeeld kostenberekening: een batchjob van 2.000 items, elk met 800 input tokens en 150 output tokens. Input: 2.000 x 800 = 1.600.000 tokens = 1,6 x $0,15 = $0,24. Output: 2.000 x 150 = 300.000 tokens = 0,3 x $0,50 = $0,15. De job kost $0,39. Mislukte of geweigerde requests worden niet in rekening gebracht, en de X-Balance-USD header laat je je saldo bekijken. Zie prijzen voor top-ups, die lopen van $20 tot $500 en kunnen worden betaald met crypto.

Agents en conversation memory

Twee patronen komen vaak naar voren nadat de eerste chain werkt. De eerste is conversation memory. LangChain's message-history helpers slaan eerdere beurtjes op en prependeren ze aan elke call. Omdat het venster 100.000 tokens is, kun je lange histories bijhouden, maar onthoud dat elke beurt ze opnieuw verstuurt. Een geschiedenis van 30.000 tokens op elk van 50 beurtjes betekent 1.500.000 input tokens, of 1,5 x $0,15 = $0,225 voor de sessie. Het samenvatten van oude beurten zodra de geschiedenis een groottelimiet passeert, houdt dat vlak.

De tweede is de agent loop. In LangGraph neemt een prebuilt agent hetzelfde llm object plus een lijst van tools en loopt tot het model stopt met vragen om tools. Stel een maximum aantal stappen in zodat een verwarde loop geen input tokens kan oplopen. Log de X-Request-Id response header voor elke call die zich vreemd gedraagt, omdat dit de identifier is om te noemen als je support contacteert.

Probleemoplossing

  • 404 op elke call. De basis-URL moet eindigen op /v1 en mag niet /chat/completions bevatten.
  • Model niet gevonden. Gebruik uncensored exact. LangChain valideert modelnamen niet voor aangepaste endpoints.
  • Token telling waarschuwingen. Sommige LangChain-functies schatten tokens met OpenAI tokenizers. De tellingen kunnen iets verschillen van het echte model, dus vertrouw op de usage teruggegeven door de API.
  • Lange agent loops worden duur. Elke loop verstuurt de volledige geschiedenis opnieuw. Knip oude tool output voordat deze de volgende call bereikt.

Als je chain er goed uitziet en toch faalt, roep het endpoint dan aan met platte curl om een LangChain-probleem van een accountprobleem te scheiden.

Vragen en antwoorden

Welke LangChain-klasse gebruik ik voor een OpenAI-compatible endpoint?

ChatOpenAI uit het langchain-openai-pakket, met base_url, api_key en model ingesteld.

Werkt tool calling met deze API?

Ja. Het ondersteunt tools, tool_choice, gestreamde tool_calls en resultaten die terugkomen met de tool-rol.

Kan ik LangChain-embeddings gebruiken met dit endpoint?

Nee. De service heeft geen embeddings-endpoint. Gebruik een andere embedding-provider of een lokaal model voor die stap.

Hoe voorkom ik 429-fouten in batchtaken?

Stel max_concurrency in op minder dan 8 voor een volledige sleutel, of minder dan 2 voor een proefsleutel, en sta een paar automatische retries toe.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de sleutel, pas de basis-URL aan. Dat is de hele configuratie.

API-sleutel aanvragen

https://api.uncensoredllmhub.com/v1