Setting up SillyTavern for AI roleplay

If you've used a few mainstream AI companion platforms and started running into their limitations (filters you don't want, memory architectures that don't suit your use, character cards you can't fully customize, no control over which model your character runs on), SillyTavern is what you should be looking at. It's the most powerful interface for AI roleplay and character chat available, and its power comes from a fundamental design choice: SillyTavern is a frontend, not a platform. It connects to whatever backend you want, runs whatever models you provide, and gives you control over essentially every variable that mainstream platforms hide.

The trade-off is setup complexity. SillyTavern isn't a one-click experience. But the resulting capability is unmatched, and once it's running, the workflow is smoother than using mainstream platforms because you've built it to fit your needs.

What SillyTavern actually is

SillyTavern is a free, open-source web interface that runs locally on your computer (or on a server you control). Think of it as the chat UI from a polished AI companion app, except the chat UI is everything: SillyTavern doesn't run AI models itself, it talks to other systems that do.

The systems SillyTavern can talk to include:

Ollama for local models LM Studio for local models
KoboldAI for local models Text Generation WebUI for local models OpenAI API for cloud GPT models Anthropic API for cloud Claude models NovelAI for cloud NovelAI models OpenRouter for access to many cloud models through a unified API AI Horde for community-shared compute

You configure SillyTavern to connect to one or more of these, and SillyTavern handles everything else: the conversation interface, character management, memory architecture, lorebooks, scenario prompts, group chats, and the dozens of features mainstream platforms either don't have or hide behind paywalls.

The result is a chat platform where every variable is yours to control. Want to run on a local 70B model with full uncensored output? Configure it. Want to use Claude for tone but switch to a local model for explicit scenes? Configure it. Want a 32K context window? Configure it. The flexibility is the entire point.

What SillyTavern enables that mainstream platforms don't

Several capabilities are either unique to SillyTavern or significantly better there than on mainstream platforms:

Lorebooks are dynamic dictionaries that inject specific context when keywords appear in the conversation. As covered in the post on character lorebooks, this is the most powerful single feature for managing complex narrative worlds. Mainstream platforms either don't have lorebooks or have severely limited versions.

Author's note at configurable depth. SillyTavern lets you inject instructions at any position in the prompt, with frequency control. The author's note technique works on every platform, but SillyTavern is where it's a first-class feature you can actually configure.

Group chats with multiple AI characters. Run scenes with three, five, or ten AI characters all interacting based on their individual character cards. Mainstream platforms generally limit this to one-on-one chat.

Direct character card editing. Every character in SillyTavern is a single PNG file (with embedded card data) that you can edit, share, or import. The character card format is industry-standard. Mainstream platforms keep characters in proprietary formats you can't move.

Multiple personas per user. Switch between different "you" characters depending on the scene. Maintain separate personas for different storylines.

Custom system prompts and presets. Configure exactly how the AI is instructed to behave. Different presets for different scenarios. Mainstream platforms hide the system prompt and you can't see or modify it.

Detailed prompt structure control. Choose what gets included in context, in what order, and with what formatting. Optimize the prompt for specific models. Mainstream platforms make these choices for you.

Vector retrieval and semantic search. Long-term memory through proper RAG implementation rather than just sliding-window summarization.

Extension ecosystem. SillyTavern supports plugins that add features beyond the core. Image generation, voice synthesis, custom tooling for specific use cases.

The capability ceiling is dramatically higher than mainstream platforms. The trade-off is that you have to actually configure it.

Installing SillyTavern

The installation process is more involved than installing a desktop app but less involved than most people expect.

On Windows:

1. Install Node.js from nodejs.org (LTS version)
2. Install Git from git-scm.com
3. Open Command Prompt or PowerShell
4. Run: git clone https://github.com/SillyTavern/SillyTavern.git
5. Navigate to the folder: cd SillyTavern
6. Run: start.bat

The first run will install dependencies. After that, SillyTavern is available at http://localhost:8000.

On macOS:

1. Install Homebrew from brew.sh if you don't have it
2. Run: brew install node git
3. Open Terminal
4. Run: git clone https://github.com/SillyTavern/SillyTavern.git
5. Navigate to the folder: cd SillyTavern
6. Run: ./start.sh

On Linux:

Similar to macOS but use your package manager (apt, dnf, pacman) to install Node.js and Git first.

The whole process takes 10-30 minutes including downloads. Once installed, you start SillyTavern by running the start script and access it through your web browser at localhost:8000.

Configuring your first backend

After SillyTavern starts, you'll see the interface but need to connect a backend before you can chat.

For local models with Ollama (the most common setup):

1. Make sure Ollama is running and has at least one model pulled
2. In SillyTavern, click the API settings (top-right area)
3. Select "Text Completion" or "Chat Completion" depending on the model
4. Choose Ollama as the API provider
5. Set the API URL to http://localhost:11434 (default)
6. Click "Connect"

If everything's working, SillyTavern will show your available Ollama models in a dropdown.

For cloud APIs, the process is similar: choose the provider, enter your API key, click connect. OpenRouter is the most flexible cloud option because it gives you access to dozens of models through one API.

The SillyTavern documentation covers backend configuration in detail for each supported provider.

Your first character

SillyTavern uses character cards as the standard format for AI personas. A character card is a PNG image with character data embedded in it. The image is the avatar; the embedded data is everything else.

Three ways to get characters:

Download from character repositories. Sites like Chub AI, Character Tavern, and various community repositories host thousands of character cards you can download. Each is a single PNG file.

Import from Character AI or similar. SillyTavern can import characters from other platforms with varying levels of fidelity.

Create your own. SillyTavern's character creator lets you build characters from scratch with a guided interface or directly editing the underlying card.

To use a downloaded character:

1. Drag the PNG file into SillyTavern's character browser
2. The character appears in your character list
3. Click to start chatting

A character card includes the character's name, description, personality, scenario, first message, example messages, and any embedded lorebook. All of this gets used to construct prompts when you chat with the character.

The first few hours

The first time you use SillyTavern feels different from mainstream platforms because you're seeing all the controls instead of having them hidden.

A few specific things to experiment with early:

Try several backends. Connect Ollama, then try a cloud provider. Notice how different models produce different conversation feels with the same character.

Edit your character. Open your character's edit panel and look at the description, personality, and scenario fields. Try modifying one and see how it affects the conversation.

Experiment with presets. SillyTavern includes several "presets" that pre-configure prompt structure for different model types. Try a few and notice how the same character feels different under different presets.

Set up a simple lorebook. Create a lorebook with two or three entries. Trigger them in conversation by mentioning the keywords. See how the AI's responses change when the lore activates.

Try the author's note. Open the author's note panel and inject a brief tonal instruction. Continue your conversation and see the influence.

These experiments build intuition for what SillyTavern is doing under the hood. After a few hours, you'll understand the architecture well enough to start optimizing for your specific needs.

Where to invest learning time

SillyTavern has a vast feature set, but a few areas reward learning more than others.

Prompt structure and presets. Understanding how SillyTavern assembles prompts (system prompt, character data, recent messages, author's note, lorebook entries, post-history instructions) is foundational. The default presets work, but customizing them for your specific use case dramatically improves results.

Lorebooks. The single most powerful feature for serious roleplay. Investing time in building well-structured lorebooks pays off across every conversation that uses them.

Model parameter tuning. Temperature, top-p, repetition penalty, and other parameters affect output character significantly. Different models prefer different parameter ranges. Learning to tune these for your specific models and use cases unlocks better outputs.

Context length management. Understanding how to configure context budget across all the different prompt elements (and what gets dropped when context fills) prevents the memory degradation patterns that frustrate mainstream platform users.

Group chat orchestration. If you want multi-character scenes, learning the group chat features takes some experimentation but produces dramatic capabilities.

The official documentation and the active community Discord cover all of this in depth. The community produces tutorials, character cards, and presets specifically for new users.

Common stumbling blocks

A few things commonly frustrate new SillyTavern users:

The interface is dense. There are panels and settings everywhere. The first impression can be overwhelming. The fix is to focus on what you need: get connected, start chatting, learn other features as you have specific problems to solve.

Local model performance. If you're running on a backend that's underpowered for the model size, conversations are sluggish. The fix is to either use a smaller model or use a cloud backend until you upgrade hardware. The hardware requirements post covers what each tier supports.

Character card quality varies enormously. Downloaded characters from public repositories range from excellent to broken. Trying several characters and learning to evaluate quality takes time.

Prompt template mismatches. Some models prefer specific prompt formats (ChatML, Vicuna, Alpaca, etc.). Using the wrong template produces noticeably worse outputs. SillyTavern handles this automatically for many models but sometimes requires manual selection.

Filter expectations. SillyTavern itself doesn't filter content, but the model you use does. If you're using a cloud API, the cloud provider's filters apply. If you're using a local model with safety training, the model itself may refuse certain content. The post on filtering covers how to think about this.

Update breaks things sometimes. SillyTavern updates frequently. Occasionally an update changes interface elements or default behavior. Most updates are smooth, but read release notes before updating major versions.

What SillyTavern is not

A few honest limitations worth naming:

Not a polished consumer product. The interface is dense by design and prioritizes power over discoverability. New users feel some friction.

Not a substitute for a great character library. Mainstream platforms have curated character libraries with millions of options. SillyTavern relies on third-party repositories that vary in quality.

Not a phone-first experience. SillyTavern works on phones via web browser but isn't optimized for mobile. Most users use it on a desktop or tablet.

Not magic. A poorly-configured SillyTavern setup with a bad model produces worse results than a well-configured mainstream platform. The capability ceiling is higher; the floor is also lower if you don't invest in the configuration.

For users who want the convenience of a polished consumer product over flexibility, mainstream platforms are still the right answer. SillyTavern is for users who've decided that the flexibility is worth the configuration time.

Why SillyTavern exists in the first place

The project started as a fork of TavernAI, originally designed for character.ai-style chat with self-hosted models. It's evolved into the most flexible AI character interface because the maintainers and community have continued adding features users want.

The community is genuinely active. Discord channels, GitHub issues, character repositories, preset libraries, and extension developers all contribute to a healthy ecosystem. Problems get fixed. Features get added. New models get supported.

This matters because SillyTavern's value depends partly on the ecosystem. The character cards, presets, lorebooks, and tutorials produced by the community make the platform more useful than it would be in isolation. Investing in SillyTavern is investing in a platform that the community is actively making better.

Frequently asked

Is SillyTavern free?

Yes, completely. The software is open source. The only costs are whatever you pay for the backend (free if you run local models, paid if you use cloud APIs).

Can I use SillyTavern without local models?

Yes. Connect to a cloud API (OpenAI, Anthropic, OpenRouter, etc.) and use cloud models entirely. You lose the privacy benefit but the rest of SillyTavern's features work the same way.

How does SillyTavern handle privacy?

SillyTavern itself doesn't send your data anywhere. The privacy of your conversations depends on the backend you use. Local models with Ollama keep everything on your machine. Cloud APIs send data to the provider you've chosen.

Can I run SillyTavern on a phone?

It works in a phone browser but isn't ideal for mobile. Most users access it from a desktop or tablet. Some users run SillyTavern on a home server and connect from their phone.

Will SillyTavern replace my mainstream AI app?

For some users, yes. For others, no. The trade-off is flexibility vs convenience. Many users end up using SillyTavern for serious sessions and a mainstream app for casual ones.

How long does setup take?

The base installation is 10-30 minutes. Getting your first conversation flowing is another 30-60 minutes. Becoming proficient with the platform is many hours of experimentation. The investment is real but not enormous.

What if I get stuck?

The official Discord is the best resource for help. Documentation at docs.sillytavern.app covers most topics. The subreddit and various community sites have detailed tutorials. Active communities make stuck problems usually solvable.