Comprehensive Guide to Cherry Studio: The Ultimate AI Workbench from Setup to Local Deployment

GPT is not omnipotent. When it fails at a task, do you keep trying in Codex or switch to another model? When one model isn't enough, you need to consider switching models, supplementing data, or letting it use tools.

Before Codex came out, I had been using Cherry Studio, and many of my friends who are deep into AI also use it. Today, let's talk about what it can do and how to make this workbench work smoothly for you.

1. What Cherry Studio Can Do

Cherry Studio is an open-source desktop AI software. GPT, Claude, DeepSeek, Kimi, and models running on your own computer can all be connected through corresponding interfaces and used within the same software.

The most attractive part for me is that while models can be swapped, frequently used materials, writing requirements, and tools stay within this workbench.

For example, when writing an article and the intro isn't satisfying, you can give the same material to several models simultaneously, have each write a version, and compare them side-by-side. Once you pick a good direction, continue editing there without repeatedly pasting between different chat websites.

If you want to keep two versions, open a "Branch" and edit them separately. If you find the original was better after a few rounds, you can return to the previous fork. Requirements for tone and format can be saved as "Assistants" so you don't have to explain them every time.

Your own articles, product manuals, and project documents can be put into a Knowledge Base. When needed, let the AI search the original text and answer based on the data; if you switch models, this data is still available.

To generate Word docs from templates, organize folders, or create a functional webpage, you can hand it over to an Agent. Once the model and tools are configured, it can read materials and operate files. After it's done, open it to check, and if something is wrong, ask it to change it.

The software also has entries for translation, drawing, etc. If you want to try open-source models or local models with fewer restrictions, you can connect them via Ollama or LM Studio, which I will explain separately later.

These common functions have ready-made entries; just configure the model and required services to use them without writing code from scratch.

2. Installing Cherry Studio

Open the Cherry Studio Official Download Page.

For Mac, choose ARM64 for Apple Silicon or x64 for Intel chips. After opening the installer, drag it into "Applications." For Windows, usually choose the x64 installer; for ARM devices, choose ARM64.

When opening for the first time, you can click "Set up later" to enter the software first.

"Chat" on the left is for writing and asking questions; "Work" is where Agents perform tasks; "Knowledge Base" stores materials for repeated lookup. Model configuration is accessed via "Settings" in the bottom left.

The top tabs are similar to a browser. You can keep the chat page open while configuring models, then switch back to test without exiting repeatedly.

3. Connecting Models

After installation, you need to connect a model. The software itself is free, but model calls may cost money, billed by the model provider.

If you like using Kimi, connect the Moonshot API; for DeepSeek, connect the DeepSeek API. You can also choose platforms that provide multiple models, like SiliconFlow, to use different models under one account. Start with one and add a second when you want to compare.

The API here can be understood as the "interface for Cherry Studio to use that model." You don't need to write code; just get a string called an API Key and fill it into the software.

API Keys are created on the provider's "Open Platform." Even if you have a chat subscription, you usually need to check if the API has credit separately, as these are often billed differently.

Taking Kimi as an example, register or log in to the Moonshot Open Platform, find API Key management, and create a key. Check if the account has available credit; if not, follow the platform's requirements to activate it. Start with a small budget.

Go back to Cherry Studio, open "Settings → Model Services," find "Moonshot," paste the key, enable the service, and click "Get Model List."

There might be several names in the list; add the one you plan to use. Go back to the chat page, click the model name at the top to switch to it. Send a short message; if it replies normally, the connection is successful.

What you connect is the model API; Kimi's web features and membership benefits won't move over. Here, you use Cherry Studio's interface and tools.

If a friend or company gives you a set of interfaces but the provider isn't in the list, click "Add Provider" at the bottom. Usually, you need this information:

The provider name can be anything you recognize, like "Company Test Interface." The Model ID cannot be arbitrary; it's the name the server uses to identify the model. If fetching the list fails, manually add it if the ID is provided.

If it doesn't connect, check the error. If the key is invalid, verify it's copied completely and filled in the right place; if credit is insufficient, check the provider balance; if the model doesn't exist, check the Model ID. The address and interface type must also match the provider's documentation.

Once the model can chat, try images, files, and tool calls. A text reply doesn't mean it supports all functions, especially for the Agent later.

As for choosing official vs. third-party services, I suggest starting with official interfaces to simplify troubleshooting. Third parties are fine, but know who the data is sent to, how it's priced, and who provides the model. A name matching a model doesn't prove it's the same service behind it.

Don't paste API Keys into chat logs or public screenshots; others could use your credit.

4. Testing Models

Once connected, test with materials you use often, like a draft, meeting notes, or product descriptions. Familiarity makes it easier to see if the answer missed anything.

For example, to summarize a long material into a short message for a colleague, give two models the same requirement:

1Summarize the following material into a message for a colleague, under 200 words.
2
3Keep confirmed conclusions, owners, times, and unresolved issues.
4Do not add what isn't in the original; do not write tentative items as confirmed.
5No intro, give the text directly.
6
7Material:
8Paste original text here.

When comparing, focus on: was the deadline kept? Was "tentative Friday" changed to "complete Friday"? These can be checked against the original without judging "intelligence" by tone.

Open the model selector at the top of the chat, enable multi-model selection, check two or three configured models, and send the same question.

If one model is better at drafts and another at checking omissions, you can use them separately later instead of making one do everything.

To check speed, go to "Settings → Appearance" and enable "Show Estimated Token Count." After a reply, check statistics to compare time-to-first-token, tokens per second, and approximate usage.

Tokens are the unit for model processing; don't treat them as exact word counts. These stats help monitor costs, but the final bill depends on the provider.

Writing models are worth testing further. Ask it to "keep the second paragraph, only change the intro, don't touch numbers" to see if it accidentally changes other parts. Having to re-check the whole text every time you change a sentence is exhausting.

Save common test questions and materials as notes. When connecting a new model, run them again. Always start a new topic for comparisons using identical materials to avoid previous chat influence.

You don't need to ask every model every time. Multi-selection sends separate requests, each potentially costing money and sending data to those services. Use it for picking schemes or titles; once a direction is set, continue with one model.

5. Managing Work with Branches

If you reach the fifth version but suddenly feel the second was better, or want to try two ways of writing the same outline, you can create a branch from the corresponding message.

Find the message you want to keep, open the message menu, and select "Branch." The new path carries the context before the fork, and subsequent discussions are recorded separately without overwriting the original path. Switch back using the branch manager.

For example, if an article has an outline but the intro isn't set, fork two branches: one starting with the conclusion, another with a specific scenario. Edit both for a few rounds, see which is better, and continue from there. You don't have to delete one to try another.

For minor edits, just follow up. If you want to keep both versions, use a branch.

If you frequently do the same type of text work, create an Assistant first. Go to "Chat → Add Assistant," give it a recognizable name like "Article Editor," and save long-term requirements:

1You help me edit Chinese articles for general readers.
2
3Prioritize keeping facts and specific examples from the draft.
4Delete fluff with no new info; don't add author background.
5When I specify a paragraph to edit, only edit that one.
6Point out judgments without evidence; do not invent sources.

Assistants store long-term habits. Specific article themes, materials, and length requirements should stay in the current topic to avoid carrying over to the next.

When reviewing, open another branch and let the model only find problems:

1Check this draft, do not rewrite.
2
3Against the materials I provided, find:
41. Facts or numbers not supported by the original.
52. Places where "possible" or "tentative" became confirmed.
63. Repetitive explanations that can be deleted.
7
8Quote the original for each and explain the issue. If no basis is found, write "source needed."

Switching models for review can sometimes find issues the previous one missed. However, content approved by both can still be wrong; always verify important facts against original data.

When only editing articles, you don't need to give the model a terminal, browser, or file tools. Turning off irrelevant tools reduces unnecessary instructions.

When moving to an Agent for files, remember to give it the final draft and requirements. The previous conversation won't automatically carry over completely; tell it explicitly which version to use.

6. Handing Tasks to Agents

Once the draft is set and needs to be formatted into Word or exported to PDF, go to "Work" on the left. Prepare the manuscript and template.

Click "Add Agent," name it by purpose, like "Data Organizer." Select the running mode, then the supported model, and fill in requirements. After creation, you can adjust tools, permissions, skills, and knowledge bases on the edit page.

The running mode affects which models and permissions are available; choose based on the current mode's list. Models for normal chat aren't necessarily suitable for Agents. Once a mode is selected, it cannot be switched directly; you'll need to create a new Agent.

Some modes feature Main, Plan, and Small models for primary work, planning, and lightweight processing. Start with the same model for all to get familiar first.

Then create a new task and select a working directory. Use a dedicated folder for practice with copies of materials. If there's a "Confirm each time" permission, use it to see what the Agent plans to read, run, and write.

Even with a working directory selected, check tool permissions. Some tools might still access files outside the directory; don't enable "Full Access" for the first time.

You can start with non-sensitive meeting notes to organize project progress:

1Read the meeting notes in the current directory and organize a project progress report.
2
3Do not modify, move, or delete original files.
4Organize into: Completed, In Progress, To be Confirmed.
5Owners and times must come from the original; mark "TBC" if not specified.
6Note the source filename after each item.
7
8List the files you found and the outline first for my confirmation.
9After confirmation, generate a new file: Project_Progress.md.

Check if the files it found are correct, then confirm the outline. After the file is generated, open it to verify, especially names, dates, and ensuring "TBC" items weren't written as confirmed.

When trying Word or PDF, you might need to install corresponding document tools or dependencies. Open the file in the output area or working directory to check content and layout.

If it needs to search the web for data, go to "Settings → Web Search" and configure a service like Exa. Get a search API Key, test it, and check if the Agent's search tool is enabled.

Search requires separate configuration and has its own quotas and fees. Without it, the model might only answer based on existing knowledge without checking the web.

If search finds a page but the task requires clicking buttons, scrolling, or downloading files, you might need browser operation capabilities. Refer to the Playwright CLI skill in skill management, install it, and assign it to the Agent.

Skills are sets of instructions, like how to operate a browser or generate docs. Some require companion tools; configure them and run a small task to test.

MCP is used to connect external tools and services, like letting an Agent access a business system. Add the service in "Settings → MCP," configure it per instructions, and bind it in the Agent's MCP settings after a successful connection.

For local meeting notes, file tools are enough. Install browser skills and MCP only when needed to avoid troubleshooting unused configurations.

In technical demos, Agents have performed three types of tasks: finding and downloading electronic textbooks, generating Word and PDF teaching materials from samples, and turning physics problems into interactive webpages with adjustable parameters.

When assigning similar tasks, be clear about textbook names, sample files, and parameters. The more specific the requirements, the easier it is to verify.

Tasks that work well in Codex can stay there. Cherry Studio offers another choice: try different models for the same work or configure different tools for different purposes.

Reuse the same Agent for weekly progress reports; for a new project, create a new task and select the corresponding folder. Create a separate one for webpage production to keep tools and requirements distinct.

7. Building a Knowledge Base

Select a batch of materials you'll use repeatedly, like product manuals or historical articles. For files read only once for a current question, upload them directly to the chat instead of building a base.

After building a base, the software splits data into segments. When you ask a question, it finds relevant original text first, then gives it to the chat model to organize an answer; data is saved and retrieved separately, not trained into the model.

Open "Knowledge Base" on the left, click add, and name it by purpose, e.g., "Product After-sales Manual." For the first time, set "Embedding Model" to "Do not use" to still allow keyword search.

Add one or two familiar files, wait for processing, and check if the parsed text is normal. Especially check scanned PDFs; if text isn't recognized, it won't be searchable.

Go to "Recall Test" in this knowledge base and ask a question with a clear answer. Recall shows which segments it retrieved. If the manual has return conditions, ask "Can I return after opening?" and check if the result is exactly that condition.

This shows the retrieved original segments, so you can check accuracy directly without guessing through the model's answer.

Once confirmed, go back to the chat, click the add button in the input area, select "Knowledge Base," and check the base. Once the name appears in the input area, ask your question:

1Based on the selected product data, organize the most frequently asked after-sales questions.
2
3Attach the corresponding source for each answer.
4For content not in the data, write "not found in data," do not add promises.
5If different files conflict, list the conflicts; do not decide for me.

If the knowledge base entry is grayed out, check if the current model supports tool calls and remove any files attached to the message. The knowledge base must also have at least one processed file.

If it can't find content when you change the wording, add an embedding model. For example, the text says "accommodation fee standards" but you ask "how much can I claim for a hotel?" The wording is different. The embedding model finds content by meaning, not the chat model that writes the final answer.

Configuration is the same as connecting models. Using SiliconFlow as an example, configure the Key in "Model Services," fetch the list, find and add models like bge-m3 in the embedding category.

Go back to Knowledge Base settings, select it under "Embedding Model," and wait for the software to index the data. If you used a different embedding model before, you'll need to rebuild as prompted. Test again with the same question.

Keyword search remains even with an embedding model. If correct content is found but ranked low, consider a Rerank model.

A Rerank model reorders retrieved segments to put more relevant ones first. Add a rerank model like bge-reranker-v2-m3 in model services, then select it in Knowledge Base settings. Available models and costs depend on the provider.

Embedding and Rerank aren't always necessary. For checking product models or clause numbers, keyword search might suffice.

For troubleshooting: if no text is found, check if the file was processed or if text is missing; if text is found but lacks context, check if segments were cut; if segments are complete but the answer is wrong, check the prompt or switch chat models.

When replacing old manuals with new ones, remove outdated entries so contradictory versions don't stay in the base. You can also ask a question not in the data to see if it admits it can't find it.

To let an Agent search these materials, bind the corresponding base in the Agent's knowledge base settings. For a product plan, give it the product manual, not all company files.

Using cloud embedding, rerank, or chat models means content may be sent to providers. Confirm if this is allowed before importing company data.

8. Connecting Local Models

To try open-source models or those with fewer restrictions, run them on your own computer and connect them to Cherry Studio. You'll use the same interface, but answers won't come from a cloud API.

Common choices are Ollama and LM Studio; one is enough. They download and run models; Cherry Studio handles connection, chat, and data organization. Hugging Face is where you find models.

First, Ollama. Download and install from the Ollama website, open a terminal, and run:

1ollama run dolphin-mistral

This is a 7B model for testing; it will download the file first. Once done, ask a question in the terminal to confirm it works.

Open Cherry Studio "Settings → Model Services," find Ollama. The service address is usually:

1http://localhost:11434

Enable the service, fetch the list, add the model, and select it in the chat.

"localhost" refers to your computer. If it fails, ensure Ollama is running, the model is downloaded, and the port hasn't changed. Don't open the service to the public internet just to connect two local apps.

If you prefer no terminal, use LM Studio. Search and download models on its search page, then load the model and start the local server. In Cherry Studio, find the LM Studio provider, enter the displayed address, and fetch the list. Cherry Studio can't use it if the model isn't loaded or the server isn't started.

To find "uncensored models," search Hugging Face for:

1uncensored GGUF

"Uncensored" is a description for fewer restrictions, not a certification. The model might refuse fewer creative requests, but it doesn't mean it's smarter or more reliable. Cherry Studio doesn't have a single "unrestrict all models" switch; you are simply choosing a different model.

GGUF is a common local model format. Check the base model, supported languages, and license before downloading the file suitable for your tool; you don't need the whole repository.

Start with 7B or 8B, Q4 quantized models. "B" is parameter scale; "Q4" means weights are compressed, using less memory with a slight effect loss. To use it in an Agent, confirm it supports tool calls.

Small models can run on ordinary computers. Dolphin Mistral is about 4 GB; a 30B Q4 weight might be 15-16 GB or more, excluding running overhead and cache for long conversations.

A computer with 16 GB RAM can try 7B or 8B quantized models; speed depends on the chip, VRAM, and context length. To run 30B, check RAM/VRAM and disk space. It might work for a few lines but slow down significantly with long materials.

When running entirely locally, input isn't sent to cloud chat services, and there's no API bill, but it uses your computer's power. If you use cloud search, embedding, or rerank, that data may still be sent out.

Note: The local embedding and OCR components downloadable in Cherry Studio settings help with retrieval and text recognition. Installing them doesn't mean you've installed a chat model.

Next time someone sends you a new model interface, connect it and run your test questions. If it fits, keep it; if not, swap it out without changing your workbench.

I am Miles, an AI algorithm expert transitioned from big tech to FDE, with experience in R&D, optimization, deployment, and corporate training. Follow me @miles_mazy to grow and earn together.