SmartChats

Voice-native, agentic, MCP-bidirectional. Open source.

SmartChats is a platform for building voice-first AI agents that talk, remember, search the web, write and run code, and integrate with everything else through the Model Context Protocol.

The same agent works two ways:

Cloud — sign up at smartchats.ai, bring your own API keys, no infra to run.
Self-hosted — run the all-in-one container on your laptop or a VPS. Same UI, same agent, same capabilities. Your data stays on your machine.

Either way, your data is yours. We respect your right to own and move your data — full human-and-agent import/export between cloud and local is built into the CLI and the MCP server. There’s no lock-in either direction.

The unlock: voice-native logging + agentic recall

This is what makes SmartChats different from a chat app:

Talk to SmartChats throughout the day from your phone (or any device). Log thoughts, observations, exercise, ideas — anything — in natural speech.

Then come back later and speak with SmartChats’s own built-in agent to recall it. Ask it to summarize the week. Pull recurring themes. Cross-reference what you logged on Tuesday with what you wrote on Friday. Have it draft a journal entry from your raw logs. Voice in. Voice (or text) out. The agent already has access to everything you’ve ever said to it.

Prefer a different tool for the recall side? Point Claude (or any other MCP-aware LLM) or the smartchats CLI at your account. Same data, your choice of interface. SmartChats is the agent — AND the substrate. Use either, use both.

Because SmartChats speaks the Model Context Protocol, any MCP-aware client can also read and search your account. You’re not locked into SmartChats’ UI for review — but the built-in agent is the natural default, and external tools are there when you want them.

   📱 your phone (voice in, all day)
              │
              ▼
       SmartChats stores
       what you said
              │
              └─────────── your data (cloud or local) ──────────┐
                                       │                         │
                                       ▼                         ▼
                              🎙️  speak directly to        🤖 (optional) Claude
                                  SmartChats's agent           or any MCP client
                                  for recall                   if you want them

And conversely — what you can ingest expands too. Anything that speaks MCP can write into your SmartChats account on your behalf. Your data becomes a substrate for any tool that wants to interact with it, not a silo.

The reverse direction: agentic ingestion → voice-native recall

This pattern is the part most people sleep on. Here’s the canonical example:

You have a folder of Obsidian markdown notes — five years of half-organized thoughts. Point an agent at the folder, tell it to read the notes and write structured data into your SmartChats account via MCP (logs, metrics, knowledge-graph triples — whatever the structure of the content suggests).

Now you can speak with that decade of notes. Ask SmartChats (or any MCP-aware LLM) to recall what you were working on in Q3 2023. Get a voice answer. Have it draw connections you’d never noticed. Migrate any document substrate into a voice-reasonable one.

   📂 your existing data                       🤖 agent reads + structures it
   (markdown, PDFs, exports                            │
    from other apps, etc.)                             ▼
              │                              MCP server writes into
              ▼                              your SmartChats account
        any agent that                              │
        can read +                                  ▼
        speak MCP                            🎙️  speak with it
                                             (SmartChats' own agent,
                                              or any MCP-aware LLM)

This is the part that’s actually new. Voice-in for personal data has existed before — barely. Voice-out reasoning over any data substrate you can structure into SmartChats? That’s the unlock.

From your perspective

Different reasons people care about SmartChats. Click the one that fits:

You spend your day in conversations, decisions, half-formed thoughts. The signal gets buried — meeting notes scattered across apps, ideas forgotten between sessions, week-old context lost.

SmartChats is your second brain that talks back. Speak to it from anywhere; come back later and speak directly to SmartChats’s own built-in agent to recall what you’ve been thinking about. Pull patterns across weeks. Get reminded of unfinished threads. Surface connections across last month’s logs.

Prefer to use a different tool for the recall side? Point Claude (or any MCP-aware LLM) or the smartchats CLI at your account — same data, your choice of interface. SmartChats doesn’t trap you in its own UI; the agent is one surface, not the only one.

The data is yours. The interface is voice. The retrieval is agentic — from inside SmartChats or from any tool you prefer.

You’re building agentic systems and you want a substrate that:

Speaks MCP both ways — read your data from any LLM client, write data into your account from any MCP-aware tool. Bidirectional, not read-only.
Has a stable, typed interface — the DataAPI contract is the same whether you’re in the chat app, the CLI, or the MCP server. Add a query builder once, every consumer picks it up.
Is open source end-to-end — no proprietary middleware, no closed protocols, no extraction risk. MIT-licensed core; cloud client adapters are open too. The CLI works against any deployment (cloud, local, your own fork).
Actually executes code — sandboxed JS runtime in the chat app, callable from the agent loop, with embedded knowledge graph and workspace state across turns.

See the Architecture page for the layered model that makes “extend SmartChats” usually a one-line change.

You log workouts, sleep, mood, water intake, weight, supplements — whatever. Most apps either lock your data into their UI or limit ingestion to a few categories. SmartChats does neither.

Ingest by voice from your phone — tell it “20 pull-ups, 30 push-ups, swam 30 minutes” and it logs each as a structured metric.
Visualize on demand — ask the agent for a chart of your weekly running distance, a streak counter for your meditation, a stacked bar of macros over the month. Graphs render inline in the chat; you don’t switch apps to see your trends.
Tag and recall freely — categories are user-defined, search is full-text + vector + structured.
Export anytime — smartchats data export produces a JSON bundle of every log, metric, and entity. Take it with you. Move it between cloud and local.
Hand it to Claude (or your favorite LLM) to draft weekly summaries, spot trends, suggest follow-ups.

Your quantified self stays yours. The retrieval, synthesis, and visualization are all agentic.

You’re building an MCP-aware client (or you ARE one — Claude Desktop, a custom agent, etc.) and SmartChats is a data source.

10 tools out of the box — search logs, recent logs, log categories, metrics, metrics summary, KG search, todos, raw query, plus import/export tools.
Authenticated end-to-end — cloud target uses your account; local target is your single-user instance. No cross-account leakage.
Same data layer as the chat app and the CLI — when SmartChats adds a feature, the MCP gets it for free. No duplicated logic.
Bidirectional — import_user_data lets you write data into a user’s account from your client. Write capability for run_query is on the near roadmap (reads only today).

See MCP Server for setup with Claude Desktop and the full tool reference.

You want a substrate for studying voice-first interaction, agentic memory, knowledge graph reasoning over time, or any number of things SmartChats happens to expose.

Open source, MIT-licensed core. Inspect, fork, modify any of it.
Self-hostable. Run the whole stack locally; nothing leaves your machine. Your data, your prompts, your model usage — all yours.
Reproducible. The schema is versioned, the test suite (bin/test_all) covers every layer, and every operation is bidirectional (export → inspect → re-import).
MCP-bidirectional. Plug in any MCP-aware client to study how agents interact with persistent voice-collected data over time.

Self-host with bin/aio, point any LLM at it, and start collecting.

Get started

Five minutes from cloud signup or local install to first conversation.

Quickstart →

bin/aio, env wizard, VPS deploys. Your data stays on your machine.

Self-Hosting →

The layered model + facade pattern + shared core that makes extending SmartChats one line.

Architecture →

Wire SmartChats into Claude Desktop or any MCP-aware LLM.

MCP Server →

What’s in the stack

The chat / voice app — Next.js, written in TypeScript, runs in your browser. Voice in via VAD + streaming ASR; voice out via streaming TTS; agent loop in between with structured-output streaming, sandboxed code execution, embedded knowledge graph.
The CLI (smartchats) — manages auth, exports/imports your data between cloud and local, launches the all-in-one stack.
The MCP server (smartchats-mcp) — speaks Model Context Protocol over stdio so any MCP-aware LLM (Claude Desktop, etc.) can read and search your SmartChats data.
The local-server + AIO container — single docker image with database + server + the Next.js app. bin/aio and you’re running.

All of it is open source.

Help

GitHub issues for bugs and feature requests.
LinkedIn (maintainer) for design discussions.
Contributing guide → for the conventions, the agent-onboarding section, and the dead-simple workflow.

Quick Start