Sidekick: A Local-First macOS Chat Client with Built-In RAG and Tool Calling

What Sidekick Actually Does Differently

Most local LLM chat clients on macOS are wrappers around a separate server like Ollama or LM Studio. Sidekick removes that dependency by embedding llama.cpp directly in the app. The README states that it is a 'local first' application with a built-in inference engine for local models, and it also accommodates OpenAI-compatible APIs for additional model options. The specific problem it solves is the friction of installing and managing a separate inference backend, plus the lack of integrated retrieval over local files. For a student writing a history paper, the example in the README shows asking a question and getting direct quotes with page numbers, with clickable references that open the source paper. That is the core value: not just a chat window, but a research assistant that can ground answers in documents you already have on your Mac.

The Mechanism: Experts, RAG, and the Built-In llama.cpp Backend

The architecture visible in the README centers on 'experts', which are individually configurable collections of resources. Each expert can contain files, folders, and websites, and activating an expert allows Sidekick to fetch and reference those materials. The README explicitly says Sidekick uses RAG, Retrieval Augmented Generation, and claims you can 'theoretically put unlimited resources into each expert' because retrieval finds relevant information on demand. That is a strong claim, but the mechanism is standard: embed the resources, then retrieve chunks relevant to the query. The built-in llama.cpp backend means local GGUF models like Qwen3.5 run without external software. You can also drag files directly into the input field for temporary access, which is a lighter weight alternative to configuring an expert. This dual path, persistent experts versus ad hoc drag and drop, is a practical design for users who need both structured research collections and quick questions about a single document.

Getting It Running: Installation and Model Configuration

The repository does not include explicit installation commands in the README excerpt, but the project is a native macOS app, so you would download the app from the releases page or build from source. The README mentions a homepage at johnbean393.github.io/Sidekick/ for feature documentation. For local models, you need GGUF format files, which are the standard for llama.cpp. The README states Sidekick supports 'modern GGUF local models such as Qwen3.5 out of the box', so you would point the app to a GGUF file you have downloaded. For remote models, you go to the provider presets, which include OpenAI, Anthropic, Google AI Studio, DeepSeek, Groq, and others, then enter an API key. There is no mention of a command line interface or a configuration file in the README, so setup is likely through the GUI. If you are used to editing a config file for model parameters, you may find this app's approach more opaque, but it does lower the barrier for non technical users.

Function Calling and Agentic Loops: What the README Shows

Sidekick implements function calling, which the README describes as a sequential loop until a result is obtained. The example is striking: asking for Q3 2025 financial metrics for Nvidia results in 27 tool calls, and the app saves a CSV file and presents results. Another example shows drafting an email by finding a birthday date and a contact's email address from the contacts book. This is a genuine agentic capability, not just a chat with retrieval. The loop mechanism is important because it implies the model can decide to call multiple tools in sequence, which is how you get complex tasks done. However, the README does not specify which functions are built in or how you can add your own. That is a gap. If you need custom tool definitions, you may have to wait for documentation or inspect the source. The 27 tool calls example also suggests that the loop can be long, which could be slow on a local model, but the README does not discuss performance.

Deep Research and Memory: The Long Horizon Features

Deep Research is a separate agent mode that handles long horizon, multi-step research tasks. The README says you specify a topic and Sidekick reads 50 to 80 webpages, synthesizing a report. That is a bold claim, and it depends on web search access, which is a separate feature. The memory feature is also notable: Sidekick remembers helpful information between conversations, and the README says it can recall details and preferences, improving responses over time. The example shows telling Sidekick you are a beginner in Python trying to create Tetris, and later getting recommendations based on that project. Memory is a double edged sword for privacy, even though the app is local first. The README says all conversations happen offline, but memory persists across sessions, so you should be aware that your history is stored locally. The app also has image generation with a built in CoreML model that automatically identifies image generation prompts, so there is no separate mode. These features make Sidekick more than a simple chat client, but they also increase the surface area for bugs, which is a risk given the release candidate status.

Limitations and Failure Modes: What the README Does Not Tell You

The README is promotional, so it does not list limitations. You can infer several. First, the app is macOS only, so Windows and Linux users are excluded. Second, the built-in llama.cpp backend means you are tied to the version of llama.cpp that Sidekick bundles, and you may not get the latest model support or performance improvements as quickly as with a standalone llama.cpp installation. Third, the claim of 'unlimited resources' in an expert is theoretical; RAG performance degrades with very large corpora if the embedding and retrieval are not optimized, and the README gives no benchmark numbers. Fourth, the function calling loop that makes 27 tool calls could be slow on a local CPU or even a Mac GPU, and there is no mention of how to monitor or cancel a runaway loop. Fifth, the deep research feature that reads 50 to 80 webpages will consume significant time and network bandwidth, and the quality of the synthesis depends on the underlying model's context window. You should verify how Sidekick handles context truncation when a report is long. Finally, memory features raise privacy questions; although it is local, the app has access to your contacts and files, so you must trust the app's permissions model.

Alternatives: How Sidekick Compares to Ollama and NotebookLM

The most direct alternative is running llama.cpp or Ollama separately and using a generic chat client like Jan or Msty. The difference is that Sidekick embeds the inference engine, so you do not install a separate server, but you also lose the flexibility of swapping backends. Ollama, for example, supports a wide range of models and has a REST API, but it does not provide a built-in RAG over your files. You would need to pair it with a tool like LangChain or a vector database. Another alternative for research focused users is Google's NotebookLM, which does RAG over your uploaded documents, but it is a cloud service, not local, and it does not run models on your Mac. Sidekick's unique position is combining local inference, RAG over local files, and function calling in one native app. If you need a cross-platform solution or you want to use a model that is not available in GGUF format, Sidekick is the wrong tool. If you want a zero setup local research assistant, it is a strong candidate.

Maintenance and License: What to Expect from a 1.0 RC

The project is under the MIT license, which is permissive and allows commercial use and modification, but you should read the repository's license file for exact terms. The latest release is 1.0.0-rc.18, dated April 2026, and the last push was May 2026, so development is active. However, being a release candidate means the API and feature set may change before a stable 1.0. The README does not mention a plugin system or a way to extend the built-in tools, so upgrades may require you to adapt to new versions. The app is written in Swift and SwiftUI, which is natural for macOS, but it also means the codebase is not portable to other platforms. If you adopt Sidekick for a long term project, you should monitor the repository for breaking changes between release candidates. The documentation is hosted on a separate homepage, which is good, but the README excerpt does not include a changelog, so you will need to check release notes for each version. The maintenance cost is moderate: you will need to update the app to get new model support and bug fixes, and you should verify that your custom experts and memory data survive updates.

Editorial conclusion

Adopt Sidekick if you are a macOS user who wants a self-contained local chat client with RAG over your own files, and you are comfortable with the built-in llama.cpp backend or willing to bring an OpenAI-compatible API key. Do not adopt it if you need a cross-platform solution, extensive model management, or a mature production tool, given the 1.0.0 release candidate status and the Mac-only scope. Before committing, verify that your preferred GGUF models run on your hardware and that the expert-based resource configuration fits your workflow. The project is MIT licensed, but check the exact terms in the repository. The decision should hinge on whether the native, local-first approach outweighs the current release maturity and platform constraints.

Official sources

1. johnbean393/Sidekick on GitHub
2. License: MIT
3. Project website
4. README
5. Releases