Best Abliterated LLM for Roleplay: API Setup Guide

What makes a model good at roleplay

Roleplay is a hard test for a language model. It has to hold a voice for hundreds of messages, remember what happened three scenes ago, stay in character when the story turns dark, and never step out to explain itself. A standard assistant model fails most often at the last point. It writes a good paragraph, then adds a disclaimer or declines a plot turn that is plain fiction.

An abliterated or uncensored model is tuned to remove those refusals. That helps, but it is only one of five traits worth checking before you commit to a provider:

• Refusal behavior. Does it follow a villain's dialogue or a morally grey scene without commentary?
• Context length. Can the character card, world notes and chat history fit in one request?
• Consistency. Does a character keep the same speech habits across a long session?
• Sampling control. Can you change temperature, top_p, penalties and stop sequences?
• Streaming. Does text appear token by token, so a reply feels like a conversation?

No one can honestly name a single winner for every story style. Taste matters, and two writers will rank the same model differently. The practical answer is to run your own scenes through a candidate and judge the output yourself.

What this API gives you for roleplay

The service runs one open-weight model, hosted by an independent provider and tuned to answer without content refusals for lawful adult use. The model ID is uncensored. There is no routing between vendors, so the voice you tested on Monday is the voice you get on Friday.

Roleplay need	What you get
Long memory	100,000 tokens of context, prompt plus completion
Live typing effect	Streaming over SSE with stream: true
Style control	temperature, top_p, stop, seed and both penalties are passed through
Client support	OpenAI-compatible, so SillyTavern and similar tools work with a URL change
Privacy	Prompts are not used for training

One hard limit applies and it is not negotiable: no sexual content involving minors. Keep your characters and scenarios on the right side of that line and within lawful adult use. The details of the model family are on the abliterated models page.

Connect SillyTavern in five steps

SillyTavern can talk to any OpenAI-compatible endpoint. Menu labels shift a little between versions, but the flow is the same.

1. Create an account and claim your key on the API key page. New users can take $0.50 of trial credit with one click, valid for 7 days, no card needed.
2. In SillyTavern, open the plug icon (API Connections) and set the API type to Chat Completion.
3. Choose the Custom (OpenAI-compatible) source.
4. Enter https://api.abliterated.cc/v1 as the endpoint URL and paste your key into the API key field.
5. Type uncensored as the model ID, then press Connect. A green status means the request to /v1/models succeeded.

If the connection fails, check the URL first. It must end in /v1 with no trailing path and no extra /chat/completions. The client adds that part itself.

Suggested starting settings

Temperature between 0.8 and 1.0 gives lively prose. Keep top_p near 0.9. Add a small frequency penalty, around 0.2, if replies start repeating the same phrases. Set a context size close to the real window, but leave room for the reply. Then adjust by feel after a few scenes.

Build your own roleplay loop in Python

If you write your own front end or a Discord bot, the OpenAI SDK is enough. This script keeps the full history, streams the reply and stops the model from writing your lines for you.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.abliterated.cc/v1",
    api_key="YOUR_KEY",
)

system = (
    "You are Mara, a smuggler captain in a sea-faring fantasy setting. "
    "Write in third person, past tense, two short paragraphs per reply. "
    "Never write the actions or words of the player character."
)
history = [{"role": "system", "content": system}]

while True:
    user = input("> ")
    history.append({"role": "user", "content": user})

    stream = client.chat.completions.create(
        model="uncensored",
        messages=history,
        temperature=0.9,
        top_p=0.9,
        frequency_penalty=0.2,
        stop=["\nPlayer:"],
        stream=True,
    )
    reply = ""
    for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            piece = chunk.choices[0].delta.content
            reply += piece
            print(piece, end="", flush=True)
    print()
    history.append({"role": "assistant", "content": reply})

The same call works from Node, curl or any other OpenAI client. Only the base URL, the key and the model ID change. The quickstart in the docs shows each variant.

Write a character card the model can follow

Most roleplay quality problems are prompt problems. A vague card produces a vague character. A good one fits in 300 to 600 tokens and covers four things: who the character is, how they talk, what they want right now, and what they must never do.

Concrete beats poetic. Compare "Mara is mysterious and dangerous" with "Mara answers questions with questions, never gives her real name to strangers, and keeps one hand near her knife when someone stands behind her." The second line gives the model behavior it can reproduce on every turn.

• Voice sample. Add two or three lines of example dialogue. Models imitate rhythm and vocabulary from examples more reliably than from adjectives.
• Format rules. State person, tense, length and whether to use asterisks for actions. Models drift on formatting unless told once, clearly.
• Scene state. Put the current place, time and open threads near the end of the prompt, where recent information has the strongest pull.
• Boundaries. If the story involves adults only, say so in the card. A line such as "all characters are adults" keeps the setting unambiguous for you and for anyone reading the logs.

Fix flat, looping or pushy characters

These are the problems that show up after the first hour, with the usual fixes.

The character repeats itself

Phrases come back every few replies. Raise frequency_penalty to 0.3 and presence_penalty to 0.1, nudge temperature up by 0.1, and check that your recap or example dialogue does not itself contain the phrase. The model copies what it sees.

Replies get longer and longer

Long replies teach the model that long replies are normal. Trim a few of them from the history, restate the length rule, and set max_tokens to a ceiling you accept. The field is optional, so it only acts as a cap when you set it.

The model decides what your character does

Add a hard rule in the system message and a stop sequence on your character's name prefix, as in the script above. If you use a front end, check that it formats history with the same name tags.

The story stalls

Give the character a goal and a clock. "She needs the map before the tide turns" produces movement. A character with nothing to want waits for you to act, and the scene sags.

Keep long stories coherent

A 100,000-token window is large, yet a months-long campaign will outgrow it. Plan for that early.

• Pin the essentials. Keep the character card and the current scene goal at the top of the system message, where they never get trimmed.
• Summarize old turns. Every 30 or 40 messages, ask the model to condense the oldest part of the chat into a short recap, then replace those messages with the recap.
• Use a lore list. Store names, places and promises in a short block you refresh each turn. Models forget a minor detail from 80 messages ago more often than a fact stated in the last prompt.
• Use seed while debugging. When you tweak a prompt, a fixed seed makes the comparison fairer.

Common failure: the model speaks for your character. Fix it in the system prompt with a direct rule and back it up with a stop sequence like the one above. Another: every reply opens the same way. Raise temperature slightly and add the frequency penalty.

What a session costs

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, paid from prepaid credit. Roleplay is input-heavy because the whole history is sent each turn, so the input side dominates.

Take a 50-turn session. The average prompt is 6,000 tokens (character card plus history) and each reply runs about 250 tokens.

• Input: 50 x 6,000 = 300,000 tokens, which is 0.3 x $0.15 = $0.045
• Output: 50 x 250 = 12,500 tokens, which is 0.0125 x $0.50 = $0.00625
• Total: $0.05125, about five cents

A $20 top-up covers roughly 390 sessions of that size. Top-ups run from $20 to $500 in whole amounts, with a bonus of +5% from $50, +10% from $100 and +15% from $200. Credit never expires and failed or refused requests are not charged. You can pay by crypto (USDT on TRC20, USDC on Base). Full numbers are on the pricing page.

More guides

• Build a Chatbot From an LLM API: Python Tutorial
• Uncensored LLM API: OpenAI-Compatible & JSON Mode