Crate do_memory_mcp 

Memory MCP (Model Context Protocol) Integration

This crate provides MCP server integration for the self-learning memory system, enabling secure code execution and memory queries through standardized tool interfaces.

Features

• MCP Server: Standard MCP server implementation with tool definitions
• Secure Sandbox: TypeScript/JavaScript code execution with comprehensive security
• Memory Integration: Query episodic memory and analyze patterns
• Progressive Disclosure: Tools are prioritized based on usage patterns
• Execution Monitoring: Detailed statistics and logging

Security

The sandbox implements defense-in-depth security:

1. Input Validation: All code is scanned for malicious patterns
2. Process Isolation: Code runs in separate Node.js processes
3. Resource Limits: CPU and memory usage are constrained
4. Timeout Enforcement: Long-running code is terminated
5. Access Controls: Network and filesystem access denied by default
6. Malicious Code Detection: Common attack patterns are blocked

Example

use do_memory_core::SelfLearningMemory;
use do_memory_mcp::server::MemoryMCPServer;
use do_memory_mcp::types::{SandboxConfig, ExecutionContext};
use serde_json::json;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create memory and server with restrictive sandbox
    let memory = Arc::new(SelfLearningMemory::new());
    let server = MemoryMCPServer::new(SandboxConfig::restrictive(), memory).await?;

    // List available tools
    let tools = server.list_tools().await;
    for tool in tools {
        println!("Tool: {} - {}", tool.name, tool.description);
    }

    // Execute code securely
    let code = r#"
        const result = {
            sum: 1 + 1,
            message: "Hello from sandbox"
        };
        return result;
    "#;

    let context = ExecutionContext::new(
        "Calculate sum".to_string(),
        json!({"a": 1, "b": 1}),
    );

    let result = server.execute_agent_code(code.to_string(), context).await?;
    println!("Result: {:?}", result);

    // Get execution statistics
    let stats = server.get_stats().await;
    println!(
        "Executed {} times, success rate: {:.1}%",
        stats.total_executions,
        stats.success_rate()
    );

    Ok(())
}

Architecture

┌─────────────────────────────────────────────────────────┐
│                    MCP Server                           │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │ Query Memory │  │Execute Code  │  │Analyze       │ │
│  │              │  │              │  │Patterns      │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
└───────────────────────┬─────────────────────────────────┘
                        │
         ┌──────────────┴──────────────┐
         ▼                             ▼
┌─────────────────┐          ┌──────────────────┐
│  Code Sandbox   │          │ Memory System    │
│  - Validation   │          │ - Episodes       │
│  - Isolation    │          │ - Patterns       │
│  - Timeout      │          │ - Heuristics     │
│  - Limits       │          │                  │
└─────────────────┘          └──────────────────┘

Re-exports

pub use batch::BatchExecutor;

pub use batch::BatchMode;

pub use batch::BatchOperation;

pub use batch::BatchRequest;

pub use batch::BatchResponse;

pub use batch::BatchStats;

pub use batch::DependencyGraph;

pub use batch::OperationError;

pub use batch::OperationResult;

pub use cache::CacheConfig;

pub use cache::CacheStats;

pub use cache::QueryCache;

pub use error::Error;

pub use error::Result;

pub use sandbox::CodeSandbox;

pub use server::MemoryMCPServer;

pub use server::audit::AuditConfig;

pub use server::audit::AuditDestination;

pub use server::audit::AuditLogEntry;

pub use server::audit::AuditLogLevel;

pub use server::audit::AuditLogger;

pub use types::ErrorType;

pub use types::ExecutionContext;

pub use types::ExecutionResult;

pub use types::ExecutionStats;

pub use types::ResourceLimits;

pub use types::SandboxConfig;

pub use types::SecurityViolationType;

pub use types::Tool;

pub use sandbox::FileSystemRestrictions;

pub use sandbox::IsolationConfig;

pub use sandbox::NetworkRestrictions;

pub use unified_sandbox::BackendHealth;

pub use unified_sandbox::SandboxBackend;

pub use unified_sandbox::UnifiedMetrics;

pub use unified_sandbox::UnifiedSandbox;

pub use wasmtime_sandbox::WasmtimeConfig;

pub use wasmtime_sandbox::WasmtimeMetrics;

pub use wasmtime_sandbox::WasmtimeSandbox;

Modules

batch

Batch request processing for MCP server

cache

Query result caching for MCP operations

error

Error types for MCP operations

jsonrpc

mcp

MCP Tools Module

monitoring

Monitoring capabilities for MCP server

patterns

Advanced Pattern Analysis Module

protocol

MCP Protocol handlers

sandbox

Secure code execution sandbox

server

MCP server for memory integration

types

MCP types for tool definitions and execution results

unified_sandbox

Sandbox abstraction layer supporting both Node.js and WASM backends

wasmtime_sandbox

Wasmtime-based WASM sandbox for secure code execution