Jean Memory

Automatically extracts and structures contextual memories from unstructured user interactions using LLM-powered analysis. The system sends conversation context to configurable LLM providers (OpenAI, Anthropic, Gemini) via a factory pattern, which parse interactions and extract key facts, preferences, and relationships. Extracted memories are then normalized and stored in vector embeddings for semantic retrieval, enabling the system to learn and retain user context across sessions without manual annotation.

Provides unified vector storage abstraction supporting Qdrant, Pinecone, Weaviate, Azure Cognitive Search, Vertex AI Vector Search, and local FAISS via a factory-based provider pattern. Memories are stored as embeddings with metadata, enabling semantic similarity search across stored memories. The system handles embedding generation, vector indexing, and retrieval through a consistent API regardless of underlying storage backend, with configurable distance metrics and filtering.

Provides official client libraries for Python (MemoryClient, AsyncMemoryClient) and TypeScript (MemoryClient) with identical APIs, enabling developers to use the same memory operations across language ecosystems. Clients handle authentication, request serialization, error handling, and retry logic transparently. Both SDKs support local and remote memory backends, enabling seamless development-to-production transitions.

Provides Docker containerization and Kubernetes manifests for self-hosted deployments of the full Jean Memory stack (backend API, MCP server, frontend UI). Deployment includes environment-based configuration for memory backends, LLM providers, and authentication. Kubernetes support enables horizontal scaling, automatic failover, and resource management for production deployments.

Automatically retrieves relevant memories from the vector store based on current conversation context and injects them into the LLM prompt before generating responses. The system performs semantic search on the query, ranks results by relevance, and formats memories as context blocks in the system prompt. This enables AI models to provide personalized, contextually-aware responses without explicit memory management by the application.

Identifies semantically similar or duplicate memories using vector similarity and LLM-powered comparison, then consolidates them into single authoritative memories. The system runs periodic deduplication jobs that cluster similar memories, merge metadata, and update relationships. This prevents memory bloat from repeated extraction of the same facts and improves retrieval efficiency.

Provides AsyncMemoryClient for non-blocking memory operations and batch APIs for bulk memory creation, updates, and deletion. The system uses Python asyncio patterns to handle concurrent memory operations without blocking, enabling high-throughput scenarios. Batch endpoints accept arrays of memory objects and process them transactionally, reducing API overhead and enabling efficient bulk imports or synchronization across multiple AI agents.

Implements MemoryGraph class that models memories as nodes in a knowledge graph with edges representing relationships (e.g., 'user prefers X', 'X is related to Y'). The system uses LLM-powered reasoning to infer relationships between extracted memories and stores them as graph edges, enabling multi-hop reasoning and contextual memory retrieval. Graph traversal can retrieve not just direct memories but related context, improving response relevance by understanding memory relationships.

Implements a Model Context Protocol server that exposes memory operations as tools callable by Claude and other MCP-compatible AI models. The server provides standardized tool definitions for memory add, retrieve, update, and delete operations, allowing AI agents to autonomously manage their own memory without explicit API calls. Tools are discoverable via MCP protocol, enabling seamless integration with Claude's tool-use capabilities and other MCP clients.

Implements LlmFactory that abstracts LLM provider selection (OpenAI, Anthropic, Google Gemini, Ollama) through a unified configuration interface. Each provider is wrapped with consistent method signatures for memory extraction and relationship inference, while supporting provider-specific optimizations (e.g., token counting for OpenAI, streaming for Anthropic). Prompts are configurable via YAML/JSON, enabling fine-tuning of memory extraction behavior without code changes.

Provides a FastAPI-based REST API exposing memory operations (add, retrieve, update, delete, search) with JWT-based authentication and configurable rate limiting. The API supports both synchronous and asynchronous endpoints, request validation via Pydantic schemas, and OpenAPI documentation. Rate limiting is enforced per API key, preventing abuse and enabling fair-use policies for multi-tenant deployments.

Tracks all memory modifications (create, update, delete) with timestamps, user IDs, and change diffs, enabling full audit trails and version history. Each memory object maintains a version number and linked list of previous versions, allowing rollback to prior states. Audit logs are immutable and queryable, supporting compliance requirements and debugging memory-related issues.

Provides EmbedderFactory supporting multiple embedding providers (OpenAI, Hugging Face, Azure OpenAI, Vertex AI, local models) with unified embedding generation interface. Each provider is wrapped with consistent method signatures for converting text to vector embeddings, while supporting provider-specific features (batch processing, dimension selection, model variants). Embeddings are cached to reduce redundant API calls and improve performance.

Provides a React-based web interface for viewing, searching, editing, and deleting memories with real-time updates. The UI displays memory content, metadata (timestamps, relevance scores), and relationships in a searchable, filterable interface. Users can manually edit memories, view extraction history, and visualize the knowledge graph of relationships. The interface integrates with the backend API and supports both local and cloud deployments.