AI Memory across your applications in 5 lines of code.

Website · Dashboard · SDK & API Docs · Report an Issue

Integrate a powerful memory layer into your application with our easy-to-use SDKs.

Drop a complete, context-aware chat component into your React app.

// 1. Install the SDK
// npm install @jeanmemory/react

// 2. Add the provider and chat component
import { JeanProvider, JeanChat } from '@jeanmemory/react';

function MyApp() {
  return (
    <JeanProvider apiKey="YOUR_API_KEY">
      <JeanChat />
    </JeanProvider>
  );
}

Add a context layer to your Python backend or AI agent.

# 1. Install the SDK
# pip install jeanmemory

# 2. Get context before calling your LLM
from jeanmemory import JeanClient

jean = JeanClient(api_key="YOUR_API_KEY")

# Get user_token from your frontend OAuth flow
context = jean.get_context(
    user_token="USER_TOKEN_FROM_FRONTEND",
    message="What was our last conversation about?"
).text

Integrate memory into your Next.js, Express, or other Node.js services.

// 1. Install the SDK
// npm install @jeanmemory/node

// 2. Get context in your API route
import { JeanClient } from '@jeanmemory/node';

const jean = new JeanClient({ apiKey: "YOUR_API_KEY" });

// Get userToken from your frontend OAuth flow
const context = await jean.getContext({
    user_token: userToken,
    message: "What was our last conversation about?"
});

➡️ Explore the full SDK Documentation for advanced usage, authentication, and more examples.

Jean Memory provides a persistent and intelligent memory layer that enables AI applications to understand users with deep, personal context. It moves beyond simple information retrieval to sophisticated context engineering, ensuring that an AI has precisely the right information at the time of inference to provide personalized, accurate, and helpful responses.

• 5-Minute Integration: Add a complete, production-ready chat UI to your React app in minutes.
• Headless SDKs: Powerful, headless libraries for Python and Node.js to integrate with any backend or agent.
• Intelligent Orchestration: Goes beyond a vector database. An AI-powered orchestration layer dynamically analyzes intent, saves new information, and retrieves the most relevant context for your LLM.
• Granular Tools: A full suite of API tools (add_memories, search_memory, deep_memory_query) for developers who need direct, fine-grained control.
• Secure and Private: User context is stored securely, under your control.
• Flexible Hosting: Use our managed cloud service for a zero-setup experience or self-host the entire stack for complete control.

Jean Memory operates on a two-layer architecture: an intelligent orchestration layer and a core API of granular tools.

1. Orchestration Layer (jean_memory tool): This is the primary, intelligent entry point. When called, this tool analyzes the user's message and conversation history to determine the optimal context strategy. It then calls the necessary core tools to gather information, synthesizes the results, and provides a perfectly engineered context package to the AI. It also handles background memory saving.

2. Core API (Granular Tools): These are the underlying building blocks that the orchestrator uses. They are also exposed via a REST API for developers who need direct, granular control for building custom agents or applications.

For detailed information, please refer to our full API Documentation.

Testing the Jean Memory SDKs? Use these guides:

• Quick 5-Minute Test - Rapid verification of all SDKs
• Complete Testing Guide - Comprehensive testing instructions

Run the entire Jean Memory stack on your local machine for development and self-hosting.

Prerequisites:

• Node.js 18+ and npm
• Python 3.12+
• Docker and Docker Compose
• Git

1. Clone the repository:

git clone https://github.com/jean-technologies/jean-memory.git
cd jean-memory

2. Navigate to the openmemory directory:

cd openmemory

3. Run one-time setup: This script will gather required API keys and generate the necessary environment files.

make setup

4. Add your API keys when prompted:

• OPENAI_API_KEY (required) - Get from the OpenAI Platform
• GEMINI_API_KEY (optional) - Get from Google AI Studio

5. Build the environment: This command builds the Docker containers and configures the environment based on your keys.

make build

6. Start the development services:

Option A: Run all services concurrently:

make dev

Option B: Run services individually in separate terminals:

# Terminal 1: Start the backend API and databases
make dev-api

# Terminal 2: Start the frontend UI
make dev-ui

7. Access the application:

• UI Dashboard: http://localhost:3000
• API Documentation: http://localhost:8765/docs
• Supabase Studio: http://localhost:54323

We welcome contributions from the community. Please read our contributing guide to get started with the development process and pull request submission.

This project incorporates code from mem0ai/mem0, which is distributed under the Apache 2.0 License. All additions and modifications made by Jean Technologies are proprietary.

• Documentation: docs.jeanmemory.com
• Bug Reports: GitHub Issues
• General Inquiries: jonathan@jeantechnologies.com