Best Uncensored LLM to Run Locally With Ollama

Short answer: pick by memory, then test two or three

There is no single best model for this, because the limit is your hardware. A model has to fit into GPU memory (or into system RAM, much more slowly) together with its working cache. The practical rule is simple: find the largest model that fits comfortably in your memory and still answers at a speed you can live with, then compare two or three candidates on your own prompts.

Model names and rankings change every few weeks, so any list written today ages fast. Skip the leaderboards and use a short method: browse the Ollama library and community uploads, filter for models described as uncensored, abliterated or fine-tuned for roleplay, pull a small and a mid-size one, and run the same ten prompts through each. Your own prompts tell you more than a score on someone else's benchmark.

If after that you find that the models that fit your machine are too small for the quality you want, a hosted endpoint is the alternative. The rest of this page lays out the trade so you can decide with numbers.

How to size a model for your machine

Three numbers decide what runs well: parameter count, quantization, and context length.

Parameters and quantization

A model with more parameters generally writes better, follows instructions more reliably and holds a character longer. But parameters take memory. At full 16-bit precision a model needs about two bytes per parameter, so a 7B model needs roughly 14 GB before any cache. Quantization shrinks that. A 4-bit version needs about half a byte per parameter, so the same 7B model fits in roughly 4 to 5 GB. Quality drops a little with each step down, and the loss is usually small at 4 to 5 bits and noticeable below that.

Context length

The context window also costs memory, because the model stores a cache of everything in the conversation. A long roleplay session or a story with a lot of earlier text needs a bigger cache. Ollama lets you set the context size per model, and a larger value uses more memory and slows down generation. Many local setups run with a window of a few thousand tokens to stay fast, which means the model forgets the start of long chats.

Speed

If a model spills out of GPU memory into system RAM, generation can fall from a pleasant reading pace to a word at a time. A smaller model that fits entirely on the GPU often feels better than a larger one that does not, even if the larger one writes slightly better.

Running a model in Ollama and calling it from code

Once Ollama is installed, pulling and chatting takes two commands, and the exact model name comes from the library page you chose:

Copyollama pull MODEL_NAME
ollama run MODEL_NAME

Ollama also serves an OpenAI-compatible API on your own machine, by default at http://localhost:11434/v1. That means the same client code can talk to a local model or a hosted one, and you switch by changing the base URL and model name:

Copyfrom openai import OpenAI

# Local Ollama (the key is ignored but must be non-empty)
local = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

# Hosted endpoint
hosted = OpenAI(base_url="https://api.ornith.top/v1", api_key="YOUR_API_KEY")

def ask(client, model, text):
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": text}],
    )
    return r.choices[0].message.content

prompt = "Write a tense two-paragraph scene set in an abandoned lighthouse."
print(ask(local, "MODEL_NAME", prompt))
print(ask(hosted, "uncensored", prompt))

Running both on the same prompts is the quickest way to answer the question for your own case. If the local output is good enough, you are done and it costs you electricity. If not, you have a baseline for what you would gain.

Local Ollama versus a hosted API

Neither is better in every case. This table sticks to what is structurally true of each approach.

Point	Local with Ollama	Hosted API
Upfront cost	Your own GPU or a machine with enough RAM	None; prepaid credit from $20
Running cost	Electricity and your time	$0.15 per 1M input tokens, $0.50 per 1M output tokens
Model size	Limited by your memory	One model chosen by the provider
Works offline	Yes	No, needs internet
Data leaves your machine	No	Yes, prompts go to the provider; ours are not used for training
Choice of model	Anything you can download	Only the one offered
Concurrent users	Bound by your hardware	Up to 8 concurrent requests on a full key
Setup	Install, pull, tune settings	Change a base URL and key

Local wins on privacy, offline use and freedom of choice. If your text must never leave your machine, or you want to swap models weekly, run locally. A hosted API wins on setup time, on not tying up your GPU while you work, and on serving an app with several users at once.

It is also fair to say what we do not offer. This service is a hosted endpoint only. There is no model file to download, no fine-tuning and no way to bring your own weights. If you want to own the model, Ollama is the right tool, and our open source LLM API guide goes through the wider set of options.

What hosted costs, worked through

People often assume a hosted model is expensive compared with free local running. Local is not free once you count hardware, but the comparison is easier with concrete usage. Prices here are $0.15 per 1M input tokens and $0.50 per 1M output tokens.

• Casual roleplay, 100 messages a day. Say each turn sends 3,000 tokens of history and gets back 300 tokens. Input per turn: 3,000 at $0.15 per 1M is $0.00045. Output: 300 at $0.50 per 1M is $0.00015. That is $0.0006 a turn, $0.06 for 100 turns, about $1.80 over 30 days.
• A writing project. 5M input tokens and 1M output tokens in a month is $0.75 plus $0.50, so $1.25.
• A small app. 200M input and 40M output tokens a month is $30 plus $20, so $50.

Only you can price your own GPU, but light and medium use costs very little hosted. The $20 minimum top-up covers a long time at the first two levels, and credit never expires, so it will not vanish if you take a month off. Larger top-ups carry a bonus: 5% from $50, 10% from $100, 15% from $200. Full details are on the pricing page.

A sensible way to combine both

You do not have to choose once. Many people run a small local model for quick drafts and private notes, and send the longer or more demanding jobs to a hosted endpoint. Because both speak the OpenAI format, your app can hold two client objects and route by task, as in the code above.

When you test the hosted side, new users can claim $0.50 of trial credit with one click on the API key page, with no card, one per person, valid for 7 days. At the per-turn figures above, that is hundreds of roleplay turns, enough to compare against your best local model on identical prompts. You can create an API key after signing in with Google or with email and password. The API docs list parameters such as temperature, top_p, stop and seed, which are passed through, so your local sampling settings carry over.

A few limits to plan for. A trial key allows 2 concurrent requests and 60 requests per minute; a full key allows 8 and 300. The context window is 100,000 tokens, far larger than what most local setups run comfortably. And the one rule that no setting changes: the model is for lawful adult use and will not produce sexual content involving minors.

More guides

• Uncensored LLM: What It Means and How to Use One
• Uncensored LLM API for SillyTavern: Setup Steps
• Open Source LLM API Guide: Setup, Costs and Alternatives