jean_memory
Primary tool for conversational interactions: saves new information and returns relevant background context; depth 0-3 sets how much context it gathers (0 none, 1 fast search, 2 balanced synthesis, 3 comprehensive analysis).
LABSCO SUMMARY
One call that decides what to retrieve, rather than four you have to sequence.
Most memory servers hand you search and store and leave the strategy to the model — which means the model spends turns deciding whether to search, and how broadly. The orchestration tool moves that decision server-side: it reads the message and the history, picks the retrieval approach, and returns an assembled context package. Over MCP there is no bypassing it: you steer it with a depth setting, from no context at all to a full analysis across memories and documents.
What it is
Jean Memory is a persistent memory layer for AI applications, reachable over MCP and through React, Python and Node SDKs. Its architecture has two levels: an orchestration tool that analyses the message and conversation history to decide a context strategy, and the granular tools underneath that it calls to do the work. Over MCP you work through the orchestration tool; the granular tools are offered directly only to clients that connect with an API key.
What you get
- An intelligent entry point that analyses intent, gathers the right context, synthesises it into one package for the model, and handles background memory saving —
jean_memory - A document upload for whole files — markdown, code, notes — processed in the background instead of pasted into the chat —
store_document - The same tools in both local and production environments, so what you develop against is what you deploy against
- SDKs that put a context-aware chat component into a React app, or fetch context in a Python or Node backend before you call your own LLM
- A self-hostable stack — API, UI and databases — run on your own machine with Docker Compose
Requirements
The managed API at api.jeanmemory.com did not answer on 2026-09-14, so this runs as a self-hosted stack, and your client reaches it through supergateway on port 8765. It needs Node.js 18+, Python 3.12+, Docker with Compose and Git; make setup collects the keys — OPENAI_API_KEY is required, GEMINI_API_KEY optional — then make build and make dev bring up the UI on port 3000 and the API on port 8765. The project incorporates code from mem0 under Apache 2.0; additions by Jean Technologies are proprietary.
Setup effort
Build from source — git clone https://github.com/jean-technologies/jean-memory.git
USE CASES
01
Giving an assistant continuity without wiring retrieval logic
Call the orchestration tool and let it decide what to fetch and what to save, instead of scripting search-then-store yourself.
02
Digging through everything, not just the top matches
Ask jean_memory at depth 3 when a quick lookup is not enough; it runs the comprehensive analysis across your memories and documents.
03
Adding memory to a React app
Wrap the app in the provider and drop in the chat component; context handling comes with it.
04
Fetching context before your own LLM call
From a Python or Node backend, request context for the user and message, then pass the text into whatever model you already use.
05
Keeping the whole stack in-house
Run the API, UI and databases locally with Docker Compose against your own OpenAI key.
3 tools
Listed in project code.
store_document
Stores a large document (markdown, code, essays) in the background and returns a job ID for status tracking.
setup_multi_agent_coordination
Sets up a multi-agent coordination workflow from a single prompt that mentions Jean Memory multi-agent coordination (Claude clients only).
BEFORE YOU INSTALL
What to know first
Tools you get
3 tools registered in the project's code. jean_memory calls add_memories, search_memory and deep_memory_query for you; the granular memory tools are offered directly only on the API-key path the SDKs use.
Requires
- Node.js 18+
- Python 3.12+
- Docker with Docker Compose
- OPENAI_API_KEY in your environment
Where it runs
The documented client runs the server on your machine.
INSTALLATION
Connect your client
This one is built from source rather than installed with a single command.
Server setup
TERMINAL
git clone https://github.com/jean-technologies/jean-memory.git
cd jean-memory
cd openmemory
make setupAdd your API keys when prompted: OPENAI_API_KEY (required), GEMINI_API_KEY (optional)
TERMINAL
make build
make devMCP Clients
Claude Desktop — local
CLAUDE DESKTOP — LOCAL · JSON
{
"mcpServers": {
"local-memory": {
"command": "npx",
"args": [
"supergateway",
"--sse",
"http://localhost:8765/mcp/claude/sse/local_dev_user"
]
}
}
}The configuration on this page does not set OPENAI_API_KEY. make setup asks for it and writes it into the environment files, outside the block.
