Add MCP HTTP/SSE server and complete n8n integration
Major Changes: - Implemented MCP HTTP/SSE transport server for n8n and web clients - Created mcp_server/http_server.py with FastAPI for JSON-RPC 2.0 over HTTP - Added health check endpoint (/health) for container monitoring - Refactored mcp-server/ to mcp_server/ (Python module structure) - Updated Dockerfile.mcp to run HTTP server with health checks MCP Server Features: - 7 memory tools exposed via MCP (add, search, get, update, delete) - HTTP/SSE transport on port 8765 for n8n integration - stdio transport for Claude Code integration - JSON-RPC 2.0 protocol implementation - CORS support for web clients n8n Integration: - Successfully tested with AI Agent workflows - MCP Client Tool configuration documented - Working webhook endpoint tested and verified - System prompt optimized for automatic user_id usage Documentation: - Created comprehensive Mintlify documentation site - Added docs/mcp/introduction.mdx - MCP server overview - Added docs/mcp/installation.mdx - Installation guide - Added docs/mcp/tools.mdx - Complete tool reference - Added docs/examples/n8n.mdx - n8n integration guide - Added docs/examples/claude-code.mdx - Claude Code setup - Updated README.md with MCP HTTP server info - Updated roadmap to mark Phase 1 as complete Bug Fixes: - Fixed synchronized delete operations across Supabase and Neo4j - Updated memory_service.py with proper error handling - Fixed Neo4j connection issues in delete operations Configuration: - Added MCP_HOST and MCP_PORT environment variables - Updated .env.example with MCP server configuration - Updated docker-compose.yml with MCP container health checks Testing: - Added test scripts for MCP HTTP endpoint verification - Created test workflows in n8n - Verified all 7 memory tools working correctly - Tested synchronized operations across both stores Version: 1.0.0 Status: Phase 1 Complete - Production Ready 🤖 Generated with Claude Code Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Claude Code
0
mcp_server/__init__.py
Normal file
0
mcp_server/__init__.py
Normal file
286
mcp_server/http_server.py
Normal file
286
mcp_server/http_server.py
Normal file
@@ -0,0 +1,286 @@
|
||||
"""
|
||||
T6 Mem0 v2 MCP Server - HTTP/SSE Transport
|
||||
Exposes MCP server via HTTP for n8n MCP Client Tool
|
||||
"""
|
||||
|
||||
import logging
|
||||
import asyncio
|
||||
from typing import AsyncIterator
|
||||
from fastapi import FastAPI, Request, Response
|
||||
from fastapi.responses import StreamingResponse
|
||||
from fastapi.middleware.cors import CORSMiddleware
|
||||
from mcp.server import Server
|
||||
from mcp.types import (
|
||||
JSONRPCRequest,
|
||||
JSONRPCResponse,
|
||||
JSONRPCError,
|
||||
Tool,
|
||||
TextContent,
|
||||
ImageContent,
|
||||
EmbeddedResource
|
||||
)
|
||||
from mem0 import Memory
|
||||
import json
|
||||
|
||||
from config import mem0_config, settings
|
||||
from mcp_server.tools import MemoryTools
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=getattr(logging, settings.log_level.upper()),
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Initialize FastAPI
|
||||
app = FastAPI(
|
||||
title="T6 Mem0 v2 MCP Server",
|
||||
description="Model Context Protocol server for memory operations via HTTP/SSE",
|
||||
version="2.0.0"
|
||||
)
|
||||
|
||||
# Enable CORS for n8n
|
||||
app.add_middleware(
|
||||
CORSMiddleware,
|
||||
allow_origins=["*"],
|
||||
allow_credentials=True,
|
||||
allow_methods=["*"],
|
||||
allow_headers=["*"],
|
||||
)
|
||||
|
||||
|
||||
class MCPHTTPServer:
|
||||
"""MCP Server with HTTP/SSE transport"""
|
||||
|
||||
def __init__(self):
|
||||
self.server = Server("t6-mem0-v2")
|
||||
self.memory: Memory | None = None
|
||||
self.tools: MemoryTools | None = None
|
||||
self.setup_handlers()
|
||||
|
||||
def setup_handlers(self):
|
||||
"""Setup MCP server handlers"""
|
||||
|
||||
@self.server.list_resources()
|
||||
async def list_resources():
|
||||
return []
|
||||
|
||||
@self.server.read_resource()
|
||||
async def read_resource(uri: str) -> str:
|
||||
logger.warning(f"Resource read not implemented: {uri}")
|
||||
return ""
|
||||
|
||||
@self.server.list_tools()
|
||||
async def list_tools() -> list[Tool]:
|
||||
logger.info("Listing tools")
|
||||
if not self.tools:
|
||||
raise RuntimeError("Tools not initialized")
|
||||
return self.tools.get_tool_definitions()
|
||||
|
||||
@self.server.call_tool()
|
||||
async def call_tool(name: str, arguments: dict) -> list[TextContent | ImageContent | EmbeddedResource]:
|
||||
logger.info(f"Tool called: {name}")
|
||||
logger.debug(f"Arguments: {arguments}")
|
||||
|
||||
if not self.tools:
|
||||
raise RuntimeError("Tools not initialized")
|
||||
|
||||
handlers = {
|
||||
"add_memory": self.tools.handle_add_memory,
|
||||
"search_memories": self.tools.handle_search_memories,
|
||||
"get_memory": self.tools.handle_get_memory,
|
||||
"get_all_memories": self.tools.handle_get_all_memories,
|
||||
"update_memory": self.tools.handle_update_memory,
|
||||
"delete_memory": self.tools.handle_delete_memory,
|
||||
"delete_all_memories": self.tools.handle_delete_all_memories,
|
||||
}
|
||||
|
||||
handler = handlers.get(name)
|
||||
if not handler:
|
||||
logger.error(f"Unknown tool: {name}")
|
||||
return [TextContent(type="text", text=f"Error: Unknown tool '{name}'")]
|
||||
|
||||
try:
|
||||
return await handler(arguments)
|
||||
except Exception as e:
|
||||
logger.error(f"Tool execution failed: {e}", exc_info=True)
|
||||
return [TextContent(type="text", text=f"Error executing tool: {str(e)}")]
|
||||
|
||||
async def initialize(self):
|
||||
"""Initialize memory service"""
|
||||
logger.info("Initializing T6 Mem0 v2 MCP HTTP Server")
|
||||
logger.info(f"Environment: {settings.environment}")
|
||||
|
||||
try:
|
||||
logger.info("Initializing Mem0...")
|
||||
self.memory = Memory.from_config(config_dict=mem0_config)
|
||||
logger.info("Mem0 initialized successfully")
|
||||
|
||||
self.tools = MemoryTools(self.memory)
|
||||
logger.info("Tools initialized successfully")
|
||||
|
||||
logger.info("T6 Mem0 v2 MCP HTTP Server ready")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to initialize server: {e}", exc_info=True)
|
||||
raise
|
||||
|
||||
|
||||
# Global server instance
|
||||
mcp_server = MCPHTTPServer()
|
||||
|
||||
|
||||
@app.on_event("startup")
|
||||
async def startup():
|
||||
"""Initialize MCP server on startup"""
|
||||
await mcp_server.initialize()
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
"""Health check endpoint"""
|
||||
return {
|
||||
"status": "healthy",
|
||||
"service": "t6-mem0-v2-mcp-http",
|
||||
"transport": "http-streamable"
|
||||
}
|
||||
|
||||
|
||||
@app.post("/mcp")
|
||||
async def mcp_endpoint(request: Request):
|
||||
"""
|
||||
MCP HTTP Streamable endpoint
|
||||
|
||||
This endpoint handles MCP JSON-RPC requests and returns responses
|
||||
compatible with n8n's MCP Client Tool.
|
||||
"""
|
||||
try:
|
||||
# Parse JSON-RPC request
|
||||
body = await request.json()
|
||||
logger.info(f"Received MCP request: {body.get('method', 'unknown')}")
|
||||
|
||||
# Handle different MCP methods
|
||||
method = body.get("method")
|
||||
params = body.get("params", {})
|
||||
request_id = body.get("id")
|
||||
|
||||
if method == "tools/list":
|
||||
# List available tools
|
||||
tools = mcp_server.tools.get_tool_definitions()
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"tools": [
|
||||
{
|
||||
"name": tool.name,
|
||||
"description": tool.description,
|
||||
"inputSchema": tool.inputSchema
|
||||
}
|
||||
for tool in tools
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
elif method == "tools/call":
|
||||
# Call a tool
|
||||
tool_name = params.get("name")
|
||||
arguments = params.get("arguments", {})
|
||||
|
||||
# Route to appropriate tool handler
|
||||
handlers = {
|
||||
"add_memory": mcp_server.tools.handle_add_memory,
|
||||
"search_memories": mcp_server.tools.handle_search_memories,
|
||||
"get_memory": mcp_server.tools.handle_get_memory,
|
||||
"get_all_memories": mcp_server.tools.handle_get_all_memories,
|
||||
"update_memory": mcp_server.tools.handle_update_memory,
|
||||
"delete_memory": mcp_server.tools.handle_delete_memory,
|
||||
"delete_all_memories": mcp_server.tools.handle_delete_all_memories,
|
||||
}
|
||||
|
||||
handler = handlers.get(tool_name)
|
||||
if not handler:
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"error": {
|
||||
"code": -32602,
|
||||
"message": f"Unknown tool: {tool_name}"
|
||||
}
|
||||
}
|
||||
else:
|
||||
result = await handler(arguments)
|
||||
|
||||
# Convert TextContent to dict
|
||||
content = []
|
||||
for item in result:
|
||||
if isinstance(item, TextContent):
|
||||
content.append({
|
||||
"type": "text",
|
||||
"text": item.text
|
||||
})
|
||||
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"content": content
|
||||
}
|
||||
}
|
||||
|
||||
elif method == "initialize":
|
||||
# Handle initialization
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"protocolVersion": "2024-11-05",
|
||||
"capabilities": {
|
||||
"tools": {}
|
||||
},
|
||||
"serverInfo": {
|
||||
"name": "t6-mem0-v2",
|
||||
"version": "2.0.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else:
|
||||
# Unknown method
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"error": {
|
||||
"code": -32601,
|
||||
"message": f"Method not found: {method}"
|
||||
}
|
||||
}
|
||||
|
||||
logger.info(f"Sending response for {method}")
|
||||
return response
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error processing MCP request: {e}", exc_info=True)
|
||||
return {
|
||||
"jsonrpc": "2.0",
|
||||
"id": body.get("id") if "body" in locals() else None,
|
||||
"error": {
|
||||
"code": -32603,
|
||||
"message": f"Internal error: {str(e)}"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import uvicorn
|
||||
|
||||
port = settings.mcp_port
|
||||
|
||||
logger.info(f"Starting MCP HTTP Server on port {port}")
|
||||
uvicorn.run(
|
||||
"mcp_server.http_server:app",
|
||||
host="0.0.0.0",
|
||||
port=port,
|
||||
log_level=settings.log_level.lower()
|
||||
)
|
||||
165
mcp_server/main.py
Normal file
165
mcp_server/main.py
Normal file
@@ -0,0 +1,165 @@
|
||||
"""
|
||||
T6 Mem0 v2 MCP Server
|
||||
Model Context Protocol server for memory operations
|
||||
"""
|
||||
|
||||
import logging
|
||||
import sys
|
||||
import asyncio
|
||||
from mcp.server import Server
|
||||
from mcp.server.stdio import stdio_server
|
||||
from mcp.types import (
|
||||
Resource,
|
||||
Tool,
|
||||
TextContent,
|
||||
ImageContent,
|
||||
EmbeddedResource
|
||||
)
|
||||
from mem0 import Memory
|
||||
|
||||
from config import mem0_config, settings
|
||||
from mcp_server.tools import MemoryTools
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=getattr(logging, settings.log_level.upper()),
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
handlers=[logging.StreamHandler(sys.stderr)] # MCP uses stderr for logs
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class T6Mem0Server:
|
||||
"""T6 Mem0 v2 MCP Server"""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize MCP server"""
|
||||
self.server = Server("t6-mem0-v2")
|
||||
self.memory: Memory | None = None
|
||||
self.tools: MemoryTools | None = None
|
||||
|
||||
# Setup handlers
|
||||
self.setup_handlers()
|
||||
|
||||
def setup_handlers(self):
|
||||
"""Setup MCP server handlers"""
|
||||
|
||||
@self.server.list_resources()
|
||||
async def list_resources() -> list[Resource]:
|
||||
"""
|
||||
List available resources (for future extension)
|
||||
"""
|
||||
return []
|
||||
|
||||
@self.server.read_resource()
|
||||
async def read_resource(uri: str) -> str:
|
||||
"""
|
||||
Read resource by URI (for future extension)
|
||||
"""
|
||||
logger.warning(f"Resource read not implemented: {uri}")
|
||||
return ""
|
||||
|
||||
@self.server.list_tools()
|
||||
async def list_tools() -> list[Tool]:
|
||||
"""List available memory tools"""
|
||||
logger.info("Listing tools")
|
||||
if not self.tools:
|
||||
raise RuntimeError("Tools not initialized")
|
||||
return self.tools.get_tool_definitions()
|
||||
|
||||
@self.server.call_tool()
|
||||
async def call_tool(name: str, arguments: dict) -> list[TextContent | ImageContent | EmbeddedResource]:
|
||||
"""
|
||||
Handle tool calls
|
||||
|
||||
Args:
|
||||
name: Tool name
|
||||
arguments: Tool arguments
|
||||
|
||||
Returns:
|
||||
Tool response
|
||||
"""
|
||||
logger.info(f"Tool called: {name}")
|
||||
logger.debug(f"Arguments: {arguments}")
|
||||
|
||||
if not self.tools:
|
||||
raise RuntimeError("Tools not initialized")
|
||||
|
||||
# Route to appropriate handler
|
||||
handlers = {
|
||||
"add_memory": self.tools.handle_add_memory,
|
||||
"search_memories": self.tools.handle_search_memories,
|
||||
"get_memory": self.tools.handle_get_memory,
|
||||
"get_all_memories": self.tools.handle_get_all_memories,
|
||||
"update_memory": self.tools.handle_update_memory,
|
||||
"delete_memory": self.tools.handle_delete_memory,
|
||||
"delete_all_memories": self.tools.handle_delete_all_memories,
|
||||
}
|
||||
|
||||
handler = handlers.get(name)
|
||||
if not handler:
|
||||
logger.error(f"Unknown tool: {name}")
|
||||
return [TextContent(type="text", text=f"Error: Unknown tool '{name}'")]
|
||||
|
||||
try:
|
||||
return await handler(arguments)
|
||||
except Exception as e:
|
||||
logger.error(f"Tool execution failed: {e}", exc_info=True)
|
||||
return [TextContent(type="text", text=f"Error executing tool: {str(e)}")]
|
||||
|
||||
async def initialize(self):
|
||||
"""Initialize memory service"""
|
||||
logger.info("Initializing T6 Mem0 v2 MCP Server")
|
||||
logger.info(f"Environment: {settings.environment}")
|
||||
|
||||
try:
|
||||
# Initialize Mem0
|
||||
logger.info("Initializing Mem0...")
|
||||
self.memory = Memory.from_config(config_dict=mem0_config)
|
||||
logger.info("Mem0 initialized successfully")
|
||||
|
||||
# Initialize tools
|
||||
self.tools = MemoryTools(self.memory)
|
||||
logger.info("Tools initialized successfully")
|
||||
|
||||
logger.info("T6 Mem0 v2 MCP Server ready")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to initialize server: {e}", exc_info=True)
|
||||
raise
|
||||
|
||||
async def run(self):
|
||||
"""Run the MCP server"""
|
||||
try:
|
||||
# Initialize before running
|
||||
await self.initialize()
|
||||
|
||||
# Run server with stdio transport
|
||||
logger.info("Starting MCP server with stdio transport")
|
||||
async with stdio_server() as (read_stream, write_stream):
|
||||
await self.server.run(
|
||||
read_stream,
|
||||
write_stream,
|
||||
self.server.create_initialization_options()
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Server error: {e}", exc_info=True)
|
||||
raise
|
||||
|
||||
|
||||
async def main():
|
||||
"""Main entry point"""
|
||||
try:
|
||||
server = T6Mem0Server()
|
||||
await server.run()
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Server stopped by user")
|
||||
except Exception as e:
|
||||
logger.error(f"Fatal error: {e}", exc_info=True)
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
13
mcp_server/run.sh
Executable file
13
mcp_server/run.sh
Executable file
@@ -0,0 +1,13 @@
|
||||
#!/bin/bash
|
||||
# Run T6 Mem0 v2 MCP Server
|
||||
|
||||
set -e
|
||||
|
||||
# Load environment variables
|
||||
if [ -f ../.env ]; then
|
||||
export $(cat ../.env | grep -v '^#' | xargs)
|
||||
fi
|
||||
|
||||
# Run MCP server
|
||||
echo "Starting T6 Mem0 v2 MCP Server..."
|
||||
python -m mcp_server.main
|
||||
373
mcp_server/tools.py
Normal file
373
mcp_server/tools.py
Normal file
@@ -0,0 +1,373 @@
|
||||
"""
|
||||
MCP tools for T6 Mem0 v2
|
||||
Tool definitions and handlers
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Any, Dict, List
|
||||
from mcp.types import Tool, TextContent
|
||||
from mem0 import Memory
|
||||
from memory_cleanup import MemoryCleanup
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class MemoryTools:
|
||||
"""MCP tools for memory operations"""
|
||||
|
||||
def __init__(self, memory: Memory):
|
||||
"""
|
||||
Initialize memory tools
|
||||
|
||||
Args:
|
||||
memory: Mem0 instance
|
||||
"""
|
||||
self.memory = memory
|
||||
self.cleanup = MemoryCleanup(memory)
|
||||
|
||||
def get_tool_definitions(self) -> List[Tool]:
|
||||
"""
|
||||
Get MCP tool definitions
|
||||
|
||||
Returns:
|
||||
List of Tool definitions
|
||||
"""
|
||||
return [
|
||||
Tool(
|
||||
name="add_memory",
|
||||
description="Add new memory from messages. Extracts and stores important information from conversation.",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"messages": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"role": {"type": "string", "enum": ["user", "assistant", "system"]},
|
||||
"content": {"type": "string"}
|
||||
},
|
||||
"required": ["role", "content"]
|
||||
},
|
||||
"description": "Conversation messages to extract memory from"
|
||||
},
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "User identifier (optional)"
|
||||
},
|
||||
"agent_id": {
|
||||
"type": "string",
|
||||
"description": "Agent identifier (optional)"
|
||||
},
|
||||
"metadata": {
|
||||
"type": "object",
|
||||
"description": "Additional metadata (optional)"
|
||||
}
|
||||
},
|
||||
"required": ["messages"]
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="search_memories",
|
||||
description="Search memories by semantic similarity. Find relevant memories based on a query.",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"query": {
|
||||
"type": "string",
|
||||
"description": "Search query"
|
||||
},
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "Filter by user ID (optional)"
|
||||
},
|
||||
"agent_id": {
|
||||
"type": "string",
|
||||
"description": "Filter by agent ID (optional)"
|
||||
},
|
||||
"limit": {
|
||||
"type": "integer",
|
||||
"minimum": 1,
|
||||
"maximum": 50,
|
||||
"default": 10,
|
||||
"description": "Maximum number of results"
|
||||
}
|
||||
},
|
||||
"required": ["query"]
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="get_memory",
|
||||
description="Get a specific memory by its ID",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"memory_id": {
|
||||
"type": "string",
|
||||
"description": "Memory identifier"
|
||||
}
|
||||
},
|
||||
"required": ["memory_id"]
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="get_all_memories",
|
||||
description="Get all memories for a user or agent",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "User identifier (optional)"
|
||||
},
|
||||
"agent_id": {
|
||||
"type": "string",
|
||||
"description": "Agent identifier (optional)"
|
||||
}
|
||||
}
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="update_memory",
|
||||
description="Update an existing memory's content",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"memory_id": {
|
||||
"type": "string",
|
||||
"description": "Memory identifier"
|
||||
},
|
||||
"data": {
|
||||
"type": "string",
|
||||
"description": "New memory content"
|
||||
}
|
||||
},
|
||||
"required": ["memory_id", "data"]
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="delete_memory",
|
||||
description="Delete a specific memory by ID",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"memory_id": {
|
||||
"type": "string",
|
||||
"description": "Memory identifier"
|
||||
}
|
||||
},
|
||||
"required": ["memory_id"]
|
||||
}
|
||||
),
|
||||
Tool(
|
||||
name="delete_all_memories",
|
||||
description="Delete all memories for a user or agent. Use with caution!",
|
||||
inputSchema={
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "User identifier (optional)"
|
||||
},
|
||||
"agent_id": {
|
||||
"type": "string",
|
||||
"description": "Agent identifier (optional)"
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
]
|
||||
|
||||
async def handle_add_memory(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle add_memory tool call"""
|
||||
try:
|
||||
messages = arguments.get("messages", [])
|
||||
user_id = arguments.get("user_id")
|
||||
agent_id = arguments.get("agent_id")
|
||||
metadata = arguments.get("metadata", {})
|
||||
|
||||
result = self.memory.add(
|
||||
messages=messages,
|
||||
user_id=user_id,
|
||||
agent_id=agent_id,
|
||||
metadata=metadata
|
||||
)
|
||||
|
||||
memories = result.get('results', [])
|
||||
response = f"Successfully added {len(memories)} memory(ies):\n\n"
|
||||
|
||||
for mem in memories:
|
||||
response += f"- {mem.get('memory', mem.get('data', 'N/A'))}\n"
|
||||
response += f" ID: {mem.get('id', 'N/A')}\n\n"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error adding memory: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_search_memories(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle search_memories tool call"""
|
||||
try:
|
||||
query = arguments.get("query")
|
||||
user_id = arguments.get("user_id")
|
||||
agent_id = arguments.get("agent_id")
|
||||
limit = arguments.get("limit", 10)
|
||||
|
||||
result = self.memory.search(
|
||||
query=query,
|
||||
user_id=user_id,
|
||||
agent_id=agent_id,
|
||||
limit=limit
|
||||
)
|
||||
|
||||
# In mem0 v0.1.118+, search returns dict with 'results' key
|
||||
memories = result.get('results', []) if isinstance(result, dict) else result
|
||||
|
||||
if not memories:
|
||||
return [TextContent(type="text", text="No memories found matching your query.")]
|
||||
|
||||
response = f"Found {len(memories)} relevant memory(ies):\n\n"
|
||||
|
||||
for i, mem in enumerate(memories, 1):
|
||||
# Handle both string and dict responses
|
||||
if isinstance(mem, str):
|
||||
response += f"{i}. {mem}\n\n"
|
||||
elif isinstance(mem, dict):
|
||||
response += f"{i}. {mem.get('memory', mem.get('data', 'N/A'))}\n"
|
||||
response += f" ID: {mem.get('id', 'N/A')}\n"
|
||||
if 'score' in mem:
|
||||
response += f" Relevance: {mem['score']:.2%}\n"
|
||||
response += "\n"
|
||||
else:
|
||||
response += f"{i}. {str(mem)}\n\n"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error searching memories: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_get_memory(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle get_memory tool call"""
|
||||
try:
|
||||
memory_id = arguments.get("memory_id")
|
||||
|
||||
memory = self.memory.get(memory_id=memory_id)
|
||||
|
||||
if not memory:
|
||||
return [TextContent(type="text", text=f"Memory not found: {memory_id}")]
|
||||
|
||||
response = f"Memory Details:\n\n"
|
||||
response += f"ID: {memory.get('id', 'N/A')}\n"
|
||||
response += f"Content: {memory.get('memory', memory.get('data', 'N/A'))}\n"
|
||||
|
||||
if memory.get('user_id'):
|
||||
response += f"User ID: {memory['user_id']}\n"
|
||||
if memory.get('agent_id'):
|
||||
response += f"Agent ID: {memory['agent_id']}\n"
|
||||
if memory.get('metadata'):
|
||||
response += f"Metadata: {memory['metadata']}\n"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting memory: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_get_all_memories(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle get_all_memories tool call"""
|
||||
try:
|
||||
user_id = arguments.get("user_id")
|
||||
agent_id = arguments.get("agent_id")
|
||||
|
||||
result = self.memory.get_all(
|
||||
user_id=user_id,
|
||||
agent_id=agent_id
|
||||
)
|
||||
|
||||
# In mem0 v0.1.118+, get_all returns dict with 'results' key
|
||||
memories = result.get('results', []) if isinstance(result, dict) else result
|
||||
|
||||
if not memories:
|
||||
return [TextContent(type="text", text="No memories found.")]
|
||||
|
||||
response = f"Retrieved {len(memories)} memory(ies):\n\n"
|
||||
|
||||
for i, mem in enumerate(memories, 1):
|
||||
# Handle both string and dict responses
|
||||
if isinstance(mem, str):
|
||||
response += f"{i}. {mem}\n\n"
|
||||
elif isinstance(mem, dict):
|
||||
response += f"{i}. {mem.get('memory', mem.get('data', 'N/A'))}\n"
|
||||
response += f" ID: {mem.get('id', 'N/A')}\n\n"
|
||||
else:
|
||||
response += f"{i}. {str(mem)}\n\n"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting all memories: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_update_memory(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle update_memory tool call"""
|
||||
try:
|
||||
memory_id = arguments.get("memory_id")
|
||||
data = arguments.get("data")
|
||||
|
||||
result = self.memory.update(
|
||||
memory_id=memory_id,
|
||||
data=data
|
||||
)
|
||||
|
||||
response = f"Memory updated successfully:\n\n"
|
||||
response += f"ID: {result.get('id', memory_id)}\n"
|
||||
response += f"New Content: {data}\n"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error updating memory: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_delete_memory(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""Handle delete_memory tool call"""
|
||||
try:
|
||||
memory_id = arguments.get("memory_id")
|
||||
|
||||
self.memory.delete(memory_id=memory_id)
|
||||
|
||||
return [TextContent(type="text", text=f"Memory {memory_id} deleted successfully.")]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error deleting memory: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
|
||||
async def handle_delete_all_memories(self, arguments: Dict[str, Any]) -> List[TextContent]:
|
||||
"""
|
||||
Handle delete_all_memories tool call
|
||||
|
||||
IMPORTANT: Uses synchronized deletion to ensure both
|
||||
Supabase (vector store) and Neo4j (graph store) are cleaned up.
|
||||
"""
|
||||
try:
|
||||
user_id = arguments.get("user_id")
|
||||
agent_id = arguments.get("agent_id")
|
||||
|
||||
# Use synchronized deletion to clean up both Supabase and Neo4j
|
||||
result = self.cleanup.delete_all_synchronized(
|
||||
user_id=user_id,
|
||||
agent_id=agent_id
|
||||
)
|
||||
|
||||
filter_str = f"user_id={user_id}" if user_id else f"agent_id={agent_id}" if agent_id else "all filters"
|
||||
response = f"All memories deleted for {filter_str}.\n"
|
||||
response += f"Supabase: {'✓' if result['supabase_success'] else '✗'}, "
|
||||
response += f"Neo4j: {result['neo4j_nodes_deleted']} nodes deleted"
|
||||
|
||||
return [TextContent(type="text", text=response)]
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error deleting all memories: {e}")
|
||||
return [TextContent(type="text", text=f"Error: {str(e)}")]
|
||||
Reference in New Issue
Block a user