Wat je nodig hebt voordat je begint
LangChain communiceert met elke server die het OpenAI chat completions protocol implementeert, dus er hoeft geen speciale integratie te worden geïnstalleerd. Je startpunt is hetzelfde pakket dat je voor OpenAI zelf zou gebruiken: langchain-openai voor Python of @langchain/openai voor Node. Slechts drie waarden veranderen.
- Base URL:
https://api.deepseekapipricing.com/v1 - Model:
uncensored - Sleutel: verstuurd als
Authorization: Bearer <key>, wat de client voor je doet
Een verduidelijking over de naamgeving. Dit endpoint is een onafhankelijke dienst die één open-weight model draait dat is afgestemd op het beantwoorden zonder content refusals voor legaal gebruik door volwassenen. Het is niet de officiële DeepSeek API en geen router tussen leveranciers, dus de modelnaam is altijd uncensored, geen leveranciers-model-ID. Als je een sleutel nodig hebt, toont de API key-pagina de aanmeldstappen en de one-click $0,50 trial.
Installeer en maak de eerste call in Python
Installeer de packages:
pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"
Maak vervolgens het model object aan. Geef de sleutel expliciet door in plaats van te vertrouwen op de OPENAI_API_KEY omgevingsvariabele, die een echte OpenAI-sleutel kan bevatten die je niet naar een andere host wilt sturen.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
temperature=0.7,
max_retries=2,
)
print(llm.invoke("Say hello in five words.").content)
Als dit een begroeting weergeeft, zijn de verbinding, de sleutel en de modelnaam allemaal correct. De meest voorkomende fout op dit stadium is het weglaten van /v1 in de basis-URL, wat meestal een not-found fout oplevert.
Prompts, chains en streaming
Vanaf hier werkt LangChain zoals gebruikelijk. Een prompt-sjabloon, het model en een output parser vormen samen een chain met de pipe-operator:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You write tight, vivid scene descriptions for adult fiction."),
("human", "Describe this setting in under 80 words: {setting}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))
Streaming verloopt via server-verzonden gebeurtenissen. In LangChain roep je stream aan, en elke chunk bevat een stuk tekst. Stel stream_usage=True in op het model als je tokenaantallen aan het einde van de stream wilt; de API stuurt verbruik in het laatste event.
llm_stream = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
stream_usage=True,
)
for chunk in llm_stream.stream("Write a four-line poem about a night train."):
print(chunk.content, end="", flush=True)
Een gestreamd verzoek houdt zijn concurrentieslot vast tot de stream klaar is, dus als je een stream verlaat zonder deze te sluiten, blijft dat slot langer bezet dan je verwacht.
Node en TypeScript
Het JavaScript-pakket neemt de basis-URL op in een configuration-object:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
maxRetries: 2,
});
const res = await llm.invoke("Say hello in five words.");
console.log(res.content);
const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
Voer het uit als een ES-module ("type": "module" in package.json, of een .mjs-bestand). Alles anders in de Node API, inclusief prompt templates en runnables, gedraagt zich zoals bij elk ander chatmodel.
Function calling en agenten
De API ondersteunt het OpenAI tool formaat: de parameters tools en tool_choice, gestreamde tool_calls, en tool resultaten die als berichten met role: "tool" worden teruggegeven. In LangChain declareer je tools met een decorator en koppel je ze met bind_tools:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage
@tool
def order_status(order_id: str) -> str:
"""Return the shipping status of an order."""
return f"Order {order_id} left the warehouse yesterday."
llm_tools = llm.bind_tools([order_status])
messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
De loop een keer met de hand schrijven is tien minuten waard. Het laat precies zien wat het model heeft geretourneerd, welke argumenten het heeft gekozen voor elke call, en waar een slechte toolbeschrijving leidt tot een verkeerde gok. Zodra dat duidelijk is, schakel je over op een prebuilt agent en houd je de handgeschreven versie als foutopsporingsreferentie.
Dat is de hele loop met de hand: het model vraagt om een tool, je voert die uit, je retourneert het resultaat, en het model schrijft het eindantwoord. Als je de voorkeur geeft aan een kant-en-klare agent loop, biedt het langgraph-pakket create_react_agent(llm, [order_status]) aan, en je roept het aan met {"messages": [("user", "Where is order 1042?")]}.
Hoe goed een model tools kiest, hangt af van het model, dus test met je echte tool schemas. Korte, specifieke toolbeschrijvingen en een lage temperature helpen. Een agent die zes calls maakt met een groeiende geschiedenis van in totaal ongeveer 27.000 input tokens en 1.800 output tokens kost ongeveer $0,00405 plus $0,0009, of ongeveer een halve cent.
Gestructureerde uitvoer met JSON-modus
JSON-modus wordt ondersteund via response_format. Koppel het aan het model en geef ook in de prompt aan dat je JSON met specifieke sleutels wilt, omdat de format flag de syntaxis regelt, niet je schema:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Return a JSON object with keys title (string) and tags (list of 3 strings) "
"for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])
Valideer het geparseerde resultaat met Pydantic of je eigen controles voordat je het vertrouwt, en behandel json.JSONDecodeError met één retry. Voor grote extractietaken, parse elke respons defensief in plaats van ervan uit te gaan dat de eerste schoon is.
Retrieval, memory en callbacks
Deze API heeft geen embeddings endpoint, dus een retrieval pipeline heeft een aparte bron van embeddings nodig. Alles na retrieval is gewone chat. Een typische retrieval chain haalt de bovenste passages uit je vector store, plakt ze in de prompt en vraagt het model om te antwoorden op basis van die tekst. Omdat het contextvenster 100.000 tokens is, kun je ruime passages veroorloven, maar onthoud de rekening: elke token van opgehaalde context is input bij $0,15 per miljoen, dus 20.000 tokens context kosten $0,003 per vraag.
Voor chat memory is de eenvoudigste aanpak een message list die je trimt op token count voor elke call. LangChain biedt helpers zoals trim_messages hiervoor. Houd het system message en de laatste turns vast, en verwijder of vat het midden samen zodra de history een limiet bereikt die je kiest. Een kleinere history houdt antwoorden ook gefocust en verlaagt de kosten van elke turn, omdat de hele history elke keer opnieuw als input wordt verstuurd.
Callbacks zijn de plek om vast te leggen wat een call kost. Elke response bevat een usage block met prompt en completion tokens, en in LangChain draagt het teruggegeven bericht dit in usage_metadata:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")
Log de kosten met de request ID zodat een verrassende rekening kan worden teruggevoerd op één chain.
System prompts en toon
Het model heeft geen ingebouwde content refusals, dus het system message is waar je het gedrag van je product instelt: het persona, de toon, de onderwerpen die het moet vermijden en het formaat van het antwoord. Schrijf het alsof je een brief schrijft voor een nieuwe collega. Kort en specifiek werkt beter dan lang en vaag. Content met minderjarigen is een harde limiet op deze service, dus bouw geen prompts die daar dicht tegenaan zitten.
Een korte checklist voordat je live gaat
- De sleutel zit in een environment variable of een secret store, nooit in de repository.
max_concurrencyis ingesteld op de limiet van je sleutel, of lager als andere services de sleutel delen.- Retries gebruiken een korte back-off, en 429 responses met
Retry-After: 5worden gerespecteerd. - Streams worden gesloten bij client disconnect zodat slots vrijkomen.
- JSON-uitvoer wordt defensief geparsed en gevalideerd.
- Kosten worden per chain gelogd vanuit het usage block.
- Er bestaat een fallback voor het geval het endpoint onbereikbaar is, zelfs als de fallback een error message is.
Volg die lijst en de integratie gedraagt zich als elk ander LangChain chat model. Het verschil zit aan de contentkant, waar requests die andere modellen weigeren voor legaal gebruik door volwassenen, worden beantwoord.
Rate limits, concurrency en veelvoorkomende fouten
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 gelijktijdige verzoeken en 60 per minuut toe. De request body kan maximaal 8 MB zijn, en het contextvenster is 100.000 tokens, zowel prompt als completion samen.
LangChain's batch helpers verspreiden requests parallel, dus stel een plafond in dat bij je sleutel past:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})
Gebruik 2 in plaats van 8 op een proefsleutel. Wanneer je een limiet overschrijdt, retourneert de API HTTP 429 met de error code rate_limited (te veel requests per minuut) of concurrency (te veel tegelijk). Bij tijdelijke overload retourneert het ook 429, met een Retry-After: 5 header. De max_retries instelling in de client behandelt tijdelijke gevallen, maar als je de error code concurrency herhaaldelijk ziet, verlaag dan max_concurrency in plaats van retries toe te voegen.
- Not-found fouten bij elke call: controleer of de base URL eindigt op
/v1. - Authentication error: de sleutel ontbreekt of heeft een typo; bevestig dat deze wordt doorgegeven via
api_key. - Model fouten: de modelnaam moet exact
uncensoredzijn. - Trage batchruns: vastgelopen streams houden concurrency-slots vast, dus sluit ze of stel een timeout in.
Prijzen zijn $0,15 per miljoen input-tokens en $0,50 per miljoen output-tokens, en mislukte of geweigerde verzoeken worden niet in rekening gebracht. De prijzenpagina vermeldt opwaarderingen, en de documentatie behandelt elke parameter en de response-headers, waaronder X-Request-Id en X-Balance-USD, wat handig is om te loggen in een LangChain-callback.
