mem0-integration ยท diff
git:20260507.44b06c0 to git:20260601.da7723a
290 added, 290 removed. Audit A to A.
- ---
- name: mem0-integration
- description: Mem0 memory layer integration for AI agents. Implement persistent, semantic memory for long-term context retention and personalization.
- allowed-tools: Read, Grep, Write, Edit, Bash, Glob, WebFetch
- graph:
- domains: [domain:software-engineering]
- specializations: [specialization:ai-agents-conversational]
- skillAreas: [skill-area:context-management, skill-area:retrieval-augmented-generation]
- roles: [role:ml-engineer, role:backend-engineer]
- workflows: [workflow:feature-development, workflow:ml-model-lifecycle]
-
- ---
-
- # mem0-integration
-
- Integrate Mem0 (formerly MemGPT) as a universal memory layer for AI agents. Enable persistent memory storage, semantic search across memories, and personalized context retrieval.
-
- ## Overview
-
- Mem0 provides intelligent memory management for AI applications:
- - Persistent storage of conversation history and facts
- - Semantic search across stored memories
- - User-specific memory isolation
- - Automatic memory extraction from conversations
- - Support for local and cloud deployments
-
- ## Capabilities
-
- ### Memory Operations
- - Add memories from text or conversations
- - Search memories semantically
- - Retrieve relevant context by user/agent
- - Update and delete memories
- - Get memory history with timestamps
-
- ### Memory Types
- - Conversation memories (dialogue history)
- - Fact memories (extracted information)
- - Preference memories (user preferences)
- - Entity memories (people, places, things)
-
- ### Storage Backends
- - Local SQLite/JSON storage
- - PostgreSQL for production
- - Qdrant vector database integration
- - Cloud-hosted Mem0 platform
-
- ### Integration Patterns
- - LangChain memory integration
- - Direct API usage
- - MCP server connectivity
- - CrewAI and AutoGen compatibility
-
- ## Usage
-
- ### Basic Setup
-
- ```python
- from mem0 import Memory
-
- # Initialize with default local storage
- m = Memory()
-
- # Or with custom configuration
- config = {
- "vector_store": {
- "provider": "qdrant",
- "config": {
- "host": "localhost",
- "port": 6333,
- }
- },
- "llm": {
- "provider": "openai",
- "config": {
- "model": "gpt-4o-mini",
- "temperature": 0.1,
- }
- }
- }
- m = Memory.from_config(config)
- ```
-
- ### Adding Memories
-
- ```python
- # Add memory from conversation
- messages = [
- {"role": "user", "content": "I prefer dark mode for all my applications"},
- {"role": "assistant", "content": "I'll remember that you prefer dark mode."}
- ]
- m.add(messages, user_id="user123")
-
- # Add memory from plain text
- m.add("User works at Acme Corp as a software engineer", user_id="user123")
-
- # Add with metadata
- m.add(
- "Prefers Python over JavaScript",
- user_id="user123",
- metadata={"category": "preferences", "confidence": 0.9}
- )
- ```
-
- ### Searching Memories
-
- ```python
- # Search for relevant memories
- results = m.search(
- query="What are the user's preferences?",
- user_id="user123",
- limit=5
- )
-
- for memory in results:
- print(f"Memory: {memory['memory']}")
- print(f"Relevance: {memory['score']}")
- print(f"Created: {memory['created_at']}")
- ```
-
- ### Getting All Memories
-
- ```python
- # Get all memories for a user
- all_memories = m.get_all(user_id="user123")
-
- # Filter by metadata
- filtered = m.get_all(
- user_id="user123",
- metadata={"category": "preferences"}
- )
- ```
-
- ### Memory History
-
- ```python
- # Get memory changes over time
- history = m.history(memory_id="mem_abc123")
-
- for entry in history:
- print(f"Version: {entry['version']}")
- print(f"Content: {entry['memory']}")
- print(f"Updated: {entry['updated_at']}")
- ```
-
- ### LangChain Integration
-
- ```python
- from langchain_openai import ChatOpenAI
- from mem0 import MemoryClient
-
- # Initialize Mem0 client
- mem0_client = MemoryClient(api_key="your-api-key")
-
- # Create LLM with memory-enhanced context
- llm = ChatOpenAI(model="gpt-4")
-
- def chat_with_memory(user_message: str, user_id: str) -> str:
- # Retrieve relevant memories
- memories = mem0_client.search(user_message, user_id=user_id, limit=5)
- memory_context = "\n".join([m["memory"] for m in memories])
-
- # Build prompt with memory context
- system_prompt = f"""You are a helpful assistant.
-
- Here is what you remember about this user:
- {memory_context}
-
- Use this context to personalize your response."""
-
- # Generate response
- response = llm.invoke([
- {"role": "system", "content": system_prompt},
- {"role": "user", "content": user_message}
- ])
-
- # Store new memory from conversation
- mem0_client.add(
- [
- {"role": "user", "content": user_message},
- {"role": "assistant", "content": response.content}
- ],
- user_id=user_id
- )
-
- return response.content
- ```
-
- ### MCP Server Usage
-
- ```python
- # Using Mem0 MCP server with Claude
- # Configure in claude_desktop_config.json:
- {
- "mcpServers": {
- "mem0": {
- "command": "npx",
- "args": ["-y", "@mem0/mcp-server"]
- }
- }
- }
- ```
-
- ## Task Definition
-
- ```javascript
- const mem0IntegrationTask = defineTask({
- name: 'mem0-integration-setup',
- description: 'Configure Mem0 memory layer for AI agent',
-
- inputs: {
- storageBackend: { type: 'string', default: 'local' }, // 'local', 'qdrant', 'postgres', 'cloud'
- vectorDimension: { type: 'number', default: 1536 },
- embeddingModel: { type: 'string', default: 'text-embedding-3-small' },
- memoryCategories: { type: 'array', default: ['facts', 'preferences', 'conversations'] },
- userIsolation: { type: 'boolean', default: true }
- },
-
- outputs: {
- configured: { type: 'boolean' },
- memoryStats: { type: 'object' },
- artifacts: { type: 'array' }
- },
-
- async run(inputs, taskCtx) {
- return {
- kind: 'skill',
- title: `Configure Mem0 with ${inputs.storageBackend} backend`,
- skill: {
- name: 'mem0-integration',
- context: {
- storageBackend: inputs.storageBackend,
- vectorDimension: inputs.vectorDimension,
- embeddingModel: inputs.embeddingModel,
- memoryCategories: inputs.memoryCategories,
- userIsolation: inputs.userIsolation,
- instructions: [
- 'Validate storage backend availability',
- 'Configure embedding model and vector dimensions',
- 'Set up memory categories and metadata schemas',
- 'Implement user isolation if enabled',
- 'Create memory add/search/retrieve functions',
- 'Test memory operations with sample data',
- 'Document integration patterns for the application'
- ]
- }
- },
- io: {
- inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
- outputJsonPath: `tasks/${taskCtx.effectId}/result.json`
- }
- };
- }
- });
- ```
-
- ## Applicable Processes
-
- - conversational-memory-system
- - long-term-memory-management
- - chatbot-design-implementation
- - conversational-persona-design
-
- ## External Dependencies
-
- - mem0ai Python package
- - Vector database (optional: Qdrant, Pinecone)
- - LLM provider (OpenAI, Anthropic, etc.)
- - Mem0 Platform API key (for cloud)
-
- ## References
-
- - [Mem0 GitHub Repository](https://github.com/mem0ai/mem0)
- - [Official Mem0 MCP](https://github.com/mem0ai/mem0-mcp)
- - [coleam00/mcp-mem0](https://github.com/coleam00/mcp-mem0)
- - [pinkpixel-dev/mem0-mcp](https://github.com/pinkpixel-dev/mem0-mcp)
- - [Mem0 Documentation](https://docs.mem0.ai)
-
- ## Related Skills
-
- - SK-MEM-001 zep-memory-integration
- - SK-MEM-003 redis-memory-backend
- - SK-MEM-004 memory-summarization
- - SK-MEM-005 entity-memory-extraction
-
- ## Related Agents
-
- - AG-MEM-001 memory-architect
- - AG-MEM-002 user-profile-builder
- - AG-MEM-003 semantic-memory-curator
+ ---
+ name: mem0-integration
+ description: Mem0 memory layer integration for AI agents. Implement persistent, semantic memory for long-term context retention and personalization.
+ allowed-tools: Read, Grep, Write, Edit, Bash, Glob, WebFetch
+ graph:
+ domains: [domain:software-engineering]
+ specializations: [specialization:ai-agents-conversational]
+ skillAreas: [skill-area:context-management, skill-area:retrieval-augmented-generation]
+ roles: [role:ml-engineer, role:backend-engineer]
+ workflows: [workflow:feature-development, workflow:ml-model-lifecycle]
+
+ ---
+
+ # mem0-integration
+
+ Integrate Mem0 (formerly MemGPT) as a universal memory layer for AI agents. Enable persistent memory storage, semantic search across memories, and personalized context retrieval.
+
+ ## Overview
+
+ Mem0 provides intelligent memory management for AI applications:
+ - Persistent storage of conversation history and facts
+ - Semantic search across stored memories
+ - User-specific memory isolation
+ - Automatic memory extraction from conversations
+ - Support for local and cloud deployments
+
+ ## Capabilities
+
+ ### Memory Operations
+ - Add memories from text or conversations
+ - Search memories semantically
+ - Retrieve relevant context by user/agent
+ - Update and delete memories
+ - Get memory history with timestamps
+
+ ### Memory Types
+ - Conversation memories (dialogue history)
+ - Fact memories (extracted information)
+ - Preference memories (user preferences)
+ - Entity memories (people, places, things)
+
+ ### Storage Backends
+ - Local SQLite/JSON storage
+ - PostgreSQL for production
+ - Qdrant vector database integration
+ - Cloud-hosted Mem0 platform
+
+ ### Integration Patterns
+ - LangChain memory integration
+ - Direct API usage
+ - MCP server connectivity
+ - CrewAI and AutoGen compatibility
+
+ ## Usage
+
+ ### Basic Setup
+
+ ```python
+ from mem0 import Memory
+
+ # Initialize with default local storage
+ m = Memory()
+
+ # Or with custom configuration
+ config = {
+ "vector_store": {
+ "provider": "qdrant",
+ "config": {
+ "host": "localhost",
+ "port": 6333,
+ }
+ },
+ "llm": {
+ "provider": "openai",
+ "config": {
+ "model": "gpt-4o-mini",
+ "temperature": 0.1,
+ }
+ }
+ }
+ m = Memory.from_config(config)
+ ```
+
+ ### Adding Memories
+
+ ```python
+ # Add memory from conversation
+ messages = [
+ {"role": "user", "content": "I prefer dark mode for all my applications"},
+ {"role": "assistant", "content": "I'll remember that you prefer dark mode."}
+ ]
+ m.add(messages, user_id="user123")
+
+ # Add memory from plain text
+ m.add("User works at Acme Corp as a software engineer", user_id="user123")
+
+ # Add with metadata
+ m.add(
+ "Prefers Python over JavaScript",
+ user_id="user123",
+ metadata={"category": "preferences", "confidence": 0.9}
+ )
+ ```
+
+ ### Searching Memories
+
+ ```python
+ # Search for relevant memories
+ results = m.search(
+ query="What are the user's preferences?",
+ user_id="user123",
+ limit=5
+ )
+
+ for memory in results:
+ print(f"Memory: {memory['memory']}")
+ print(f"Relevance: {memory['score']}")
+ print(f"Created: {memory['created_at']}")
+ ```
+
+ ### Getting All Memories
+
+ ```python
+ # Get all memories for a user
+ all_memories = m.get_all(user_id="user123")
+
+ # Filter by metadata
+ filtered = m.get_all(
+ user_id="user123",
+ metadata={"category": "preferences"}
+ )
+ ```
+
+ ### Memory History
+
+ ```python
+ # Get memory changes over time
+ history = m.history(memory_id="mem_abc123")
+
+ for entry in history:
+ print(f"Version: {entry['version']}")
+ print(f"Content: {entry['memory']}")
+ print(f"Updated: {entry['updated_at']}")
+ ```
+
+ ### LangChain Integration
+
+ ```python
+ from langchain_openai import ChatOpenAI
+ from mem0 import MemoryClient
+
+ # Initialize Mem0 client
+ mem0_client = MemoryClient(api_key="your-api-key")
+
+ # Create LLM with memory-enhanced context
+ llm = ChatOpenAI(model="gpt-4")
+
+ def chat_with_memory(user_message: str, user_id: str) -> str:
+ # Retrieve relevant memories
+ memories = mem0_client.search(user_message, user_id=user_id, limit=5)
+ memory_context = "\n".join([m["memory"] for m in memories])
+
+ # Build prompt with memory context
+ system_prompt = f"""You are a helpful assistant.
+
+ Here is what you remember about this user:
+ {memory_context}
+
+ Use this context to personalize your response."""
+
+ # Generate response
+ response = llm.invoke([
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": user_message}
+ ])
+
+ # Store new memory from conversation
+ mem0_client.add(
+ [
+ {"role": "user", "content": user_message},
+ {"role": "assistant", "content": response.content}
+ ],
+ user_id=user_id
+ )
+
+ return response.content
+ ```
+
+ ### MCP Server Usage
+
+ ```python
+ # Using Mem0 MCP server with Claude
+ # Configure in claude_desktop_config.json:
+ {
+ "mcpServers": {
+ "mem0": {
+ "command": "npx",
+ "args": ["-y", "@mem0/mcp-server"]
+ }
+ }
+ }
+ ```
+
+ ## Task Definition
+
+ ```javascript
+ const mem0IntegrationTask = defineTask({
+ name: 'mem0-integration-setup',
+ description: 'Configure Mem0 memory layer for AI agent',
+
+ inputs: {
+ storageBackend: { type: 'string', default: 'local' }, // 'local', 'qdrant', 'postgres', 'cloud'
+ vectorDimension: { type: 'number', default: 1536 },
+ embeddingModel: { type: 'string', default: 'text-embedding-3-small' },
+ memoryCategories: { type: 'array', default: ['facts', 'preferences', 'conversations'] },
+ userIsolation: { type: 'boolean', default: true }
+ },
+
+ outputs: {
+ configured: { type: 'boolean' },
+ memoryStats: { type: 'object' },
+ artifacts: { type: 'array' }
+ },
+
+ async run(inputs, taskCtx) {
+ return {
+ kind: 'skill',
+ title: `Configure Mem0 with ${inputs.storageBackend} backend`,
+ skill: {
+ name: 'mem0-integration',
+ context: {
+ storageBackend: inputs.storageBackend,
+ vectorDimension: inputs.vectorDimension,
+ embeddingModel: inputs.embeddingModel,
+ memoryCategories: inputs.memoryCategories,
+ userIsolation: inputs.userIsolation,
+ instructions: [
+ 'Validate storage backend availability',
+ 'Configure embedding model and vector dimensions',
+ 'Set up memory categories and metadata schemas',
+ 'Implement user isolation if enabled',
+ 'Create memory add/search/retrieve functions',
+ 'Test memory operations with sample data',
+ 'Document integration patterns for the application'
+ ]
+ }
+ },
+ io: {
+ inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
+ outputJsonPath: `tasks/${taskCtx.effectId}/result.json`
+ }
+ };
+ }
+ });
+ ```
+
+ ## Applicable Processes
+
+ - conversational-memory-system
+ - long-term-memory-management
+ - chatbot-design-implementation
+ - conversational-persona-design
+
+ ## External Dependencies
+
+ - mem0ai Python package
+ - Vector database (optional: Qdrant, Pinecone)
+ - LLM provider (OpenAI, Anthropic, etc.)
+ - Mem0 Platform API key (for cloud)
+
+ ## References
+
+ - [Mem0 GitHub Repository](https://github.com/mem0ai/mem0)
+ - [Official Mem0 MCP](https://github.com/mem0ai/mem0-mcp)
+ - [coleam00/mcp-mem0](https://github.com/coleam00/mcp-mem0)
+ - [pinkpixel-dev/mem0-mcp](https://github.com/pinkpixel-dev/mem0-mcp)
+ - [Mem0 Documentation](https://docs.mem0.ai)
+
+ ## Related Skills
+
+ - SK-MEM-001 zep-memory-integration
+ - SK-MEM-003 redis-memory-backend
+ - SK-MEM-004 memory-summarization
+ - SK-MEM-005 entity-memory-extraction
+
+ ## Related Agents
+
+ - AG-MEM-001 memory-architect
+ - AG-MEM-002 user-profile-builder
+ - AG-MEM-003 semantic-memory-curator