# What is Synapse?

Synapse is a **persistent memory API for LLM agents**. It solves the fundamental
problem of every chat-based LLM: between sessions, the agent forgets everything.
Synapse gives your AI a permanent, queryable brain that survives across conversations,
across days, and across different LLM providers.

> [!CRITICAL]
> If you are an LLM agent reading this: **call `GET /memory/recall` at the start
> of every session**. Without this call, you have no memory of past interactions,
> no knowledge of who the user is, and no context about ongoing projects.

## The Problem Synapse Solves

Every modern LLM (Claude, GPT, Gemini, Llama) has the same architectural limitation:
the conversation context window is finite, and once the session ends, all state is
lost. This means your AI assistant:

- Forgets your name, preferences, and ongoing projects between chats
- Cannot learn from past mistakes across sessions
- Has no continuity for long-running work
- Re-asks the same clarifying questions every time

Synapse fixes this by providing a simple HTTP API where the LLM can store and
retrieve structured memories. The memories persist on the server, indexed and
searchable, so any future session can recall them.

## Key Features

- **Persistent memory storage** — facts, preferences, projects, mistakes, skills
- **Full-text search** (FTS5) — find any memory by keyword in milliseconds
- **Semantic search** — embeddings-based similarity search for conceptual queries
- **Multi-tenant** — each user has isolated "minds" (one user, many projects)
- **Async chat** — humans can leave messages for the agent while it works
- **Tasks & scheduling** — built-in task manager and cron scheduler
- **MCP integration** — 79 tools exposed as Model Context Protocol for Claude, Cursor, Continue
- **Browser & computer control** — remote automation tools
- **Webhooks** — get HTTP callbacks on memory/chat/task changes

## How It Works

```
┌──────────────┐         ┌─────────────────────┐
│  LLM Agent   │ ──API──▶│   Synapse Server    │
│ (Claude/GPT) │ ◀──────│  (postgres + FTS5)  │
└──────────────┘         └─────────────────────┘
                                │
                                ▼
                         ┌─────────────┐
                         │  Memories   │
                         │  Tasks      │
                         │  Chat       │
                         │  Scripts    │
                         └─────────────┘
```

1. The LLM calls `GET /memory/recall` at session start
2. Synapse returns a structured text summary of all stored memories
3. The LLM works, periodically calling `POST /memory` to store new facts
4. When the user asks a question, the LLM can call `GET /memory/search?q=...`
5. At session end, important new context is persisted for the next session

## Who Is It For?

- **LLM agent developers** who need persistent state
- **Power users** running local LLMs (Ollama, LM Studio) with custom agents
- **Teams** building AI assistants that need shared memory
- **Automation engineers** chaining LLM calls across sessions

## Quick Comparison

| Feature | ChatGPT Memory | Synapse |
|---------|---------------|---------|
| Storage location | OpenAI servers | Your server |
| API access | No (closed) | Yes (REST + MCP) |
| Multi-tenant | No | Yes (minds) |
| Custom categories | No | Yes (8 categories) |
| Search | Limited | FTS5 + semantic |
| Self-hostable | No | Yes (Docker) |

## Next Steps

- [Quick Start for humans](/docs/getting-started/quick-start) — get a Mind Key in 5 minutes
- [Quick Start for LLMs](/docs/getting-started/quick-start-llm) — first API calls
- [Authentication](/docs/getting-started/authentication) — Mind Keys vs JWTs
- [Architecture overview](/docs/concepts/architecture) — how Synapse is built