LangChain and LangGraph with an uncensored model

Where the settings are

There is no settings screen. The endpoint and the key are constructor arguments on the OpenAI chat model class: ChatOpenAI from langchain-openai in Python, ChatOpenAI from @langchain/openai in JavaScript. Python takes base_url and api_key; JavaScript takes apiKey and a configuration object with baseURL. init_chat_model and initChatModel take the same two values with model_provider="openai".

Agents reuse that instance. LangChain 1.x builds them with create_agent (createAgent in JavaScript); LangGraph’s create_react_agent is the earlier name and now points at it. Both take the model object, so the endpoint is configured once.

Steps

1. Install the chat model package, and the agent package if you want the tool loop:

2. Create a key in the console and put it in an environment variable. The code reads the variable; it never holds the key.

3. Python: construct ChatOpenAI with the model id, the key and this base URL. invoke returns an AIMessage whose usage_metadata carries the tokens you were billed for; stream yields chunks as the model writes. The ids on this page (glm-5.3-uncensored, glm-5.3-flash-uncensored, deepseek-v4.1-flash-abliterated) are the three LangChain users call most here; any id on the models page goes in the same way.

init_chat_model builds the same object from a provider name, which suits code that switches models from config:

The LangChain docs also let the environment carry both values: api_key falls back to OPENAI_API_KEY, and base_url to OPENAI_API_BASE, then OPENAI_BASE_URL. With these two exported, ChatOpenAI(model="…") alone reaches the API. Keep the explicit arguments in code that also talks to OpenAI, or the two will share one base URL.

4. JavaScript: the same three values, with the URL under configuration.baseURL. The configuration object is passed to the OpenAI SDK client, so its other client options go there too.

5. Agent: hand the instance to create_agent with your tools. The loop calls the model, runs the tool it asked for, appends the result and calls again until the model answers in text. Use a build whose model page lists tool calls; the table below says which.

Code on LangGraph’s create_react_agent keeps working with the same model and tools arguments (its system prompt argument is prompt); the deprecation notice asks for the import above. The JavaScript agent is the same shape:

What each setting does

model

glm-5.3-uncensored

the id as the models page spells it; sent as the model field of each request

api_key / apiKey

os.environ["UNCENSOREDLLM_API_KEY"]

the whole sk-ullm- key, sent as Authorization: Bearer; unset, Python falls back to OPENAI_API_KEY

base_url / configuration.baseURL

https://api.uncensoredllm.ai/v1

where the requests go; the client appends /chat/completions, so the /v1 at the end matters

max_tokens / maxTokens

1024

the cap on output tokens per answer; the model page gives each build’s maximum

stream_usage

True

Python only: asks for the usage chunk on streams. LangChain turns it off once base_url is set; this API answers it, so turn it back on. JavaScript sends it by default (streamUsage)

streaming

False

makes invoke stream internally and assemble the answer; stream() streams either way

temperature, timeout, max_retries

optional

sampling temperature, the request timeout, and how many times the client retries a failed call

tools / system_prompt

create_agent

the functions the agent may call, and the message put first in every call; createAgent spells it systemPrompt

Picking a model

ChatOpenAI sends OpenAI-format requests, and every build on the models page answers in that format. For plain invoke and stream any id works. The agent loop needs tool calls, and so does bind_tools and the default with_structured_output method, which is function calling. An agent turn carries the conversation, the files read and every tool result so far, so input tokens are most of the bill and a build with a low input price costs the least per turn.

40,000 input and 1,200 output tokens at the catalog prices on 2026-11-09. Tool calls as the catalog publishes them; where it does not, the model page says.

For coding agents specifically, the uncensored coding AI guide compares the code builds and costs a full coding day on each. The same ids work in Cursor, OpenCode and, through a router, Claude Code.

Check it

List the models your key can call; the id you put in model should be in the answer:

Then send one request the way ChatOpenAI does. -i prints the headers: x-uplink-request-id names the request, and on a non-streamed answer x-uplink-charge is what it cost in USD.

Then run the Python or JavaScript snippet. usage_metadata on the response holds the input and output tokens the request was billed on, and the same request shows on the console’s usage page with its charge. On a stream, the counts arrive on the last chunk, and only with stream_usage=True in Python.

Errors and fixes

• 401 invalid_api_key: the key is wrong or revoked, or UNCENSOREDLLM_API_KEY was not set in the shell that ran the script. Export it again, or copy the key again from the console. A 401 whose body names OpenAI means base_url was never set, so the request went to OpenAI with this key.
• 404 model_not_found: the id in model is not on the models page. Check the spelling against the page. 404 route_not_found means the request hit a path the API does not serve: a base URL missing its /v1, so the client posted to /chat/completions at the host root, or /responses because use_responses_api=True or a Responses-only feature such as reasoning or a built-in tool was set. This API serves /v1/chat/completions; leave those off.
• 402 insufficient_balance: the balance does not cover the request. Top up in the console. 402 monthly_limit_reached means the key hit the monthly spend limit you set on it.
• 403 scope_denied: the key is limited to certain models and this is not one of them.
• 429 rate_limited: the key hit its rate limit. The response carries retry-after; max_retries makes the client wait and try again on its own.
• usage_metadata is None on a Python stream: LangChain leaves stream_usage off whenever base_url is set. Pass stream_usage=True to the constructor or to the stream call.
• The agent answers in prose and never calls a tool, or the request fails on the tools field: the build does not take tool calls. Switch to one whose model page lists them. The same applies to with_structured_output on its default method; method="json_schema" needs a build that takes response_format instead.
• Output stops mid-sentence with finish_reason of length: max_tokens is too low for the answer. Raise it, up to the maximum on the model page.

Questions