知识图谱内存服务器

cd rust/memory-mcp-rs
cargo build --release

Usage: memory-mcp-rs [OPTIONS]

Options:
      --db-path <DB_PATH>    Database file path (default: system data dir or MEMORY_FILE_PATH env)
  -s, --stream               Enable streamable HTTP mode (default: stdio)
  -p, --port <PORT>          HTTP port for stream mode [default: 8000]
  -b, --bind <BIND>          Bind address for stream mode [default: 127.0.0.1]
  -l, --log [<FILE>]         Enable file logging [default: memory-mcp-rs.log]
  -h, --help                 Print help
  -V, --version              Print version

# Default path: %LOCALAPPDATA%/mcp-memory/knowledge_graph.db (Windows)
# or ~/.local/share/mcp-memory/knowledge_graph.db (Linux/Mac)
memory-mcp-rs

# Custom database path (CLI flag)
memory-mcp-rs --db-path /path/to/graph.db

# Custom database path (environment variable)
MEMORY_FILE_PATH=/path/to/graph.db memory-mcp-rs

# With file logging (for debugging)
memory-mcp-rs --log debug.log

# Start HTTP server on default port 8000
memory-mcp-rs --stream

# Custom port and bind address
memory-mcp-rs --stream --port 9000 --bind 0.0.0.0

# With logging to both console and file
memory-mcp-rs --stream --log server.log

# Health check
curl http://localhost:8000/health
# Returns: OK

{
  "mcpServers": {
    "memory": {
      "command": "C:\\path\\to\\memory-mcp-rs.exe"
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "/path/to/memory-mcp-rs"
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "memory-mcp-rs",
      "args": []
    }
  }
}

# Terminal 1: Start HTTP server
memory-mcp-rs --stream --port 8000

# Terminal 2: Add to .claude/mcp.json
{
  "mcpServers": {
    "memory-http": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "memory-mcp-rs"
    }
  }
}

# Terminal 1: Start HTTP server
memory-mcp-rs --stream --port 8000 --log server.log

# Terminal 2: Configure Codex to use http://localhost:8000/mcp

src/
├── main.rs       # MCP server + tool routing + dual-mode transport
├── logging.rs    # Transport-aware logging (stdio vs HTTP)
├── graph.rs      # Data structures (Entity, Relation, KnowledgeGraph)
├── manager.rs    # Async manager wrapping storage
└── storage.rs    # SQLite implementation

-- Entities
CREATE TABLE entities (
    name TEXT PRIMARY KEY,
    entity_type TEXT NOT NULL,
    observations TEXT NOT NULL  -- JSON array
);

-- Relations with cascade delete
CREATE TABLE relations (
    from_entity TEXT NOT NULL,
    to_entity TEXT NOT NULL,
    relation_type TEXT NOT NULL,
    FOREIGN KEY(from_entity) REFERENCES entities(name) ON DELETE CASCADE,
    FOREIGN KEY(to_entity) REFERENCES entities(name) ON DELETE CASCADE
);

-- FTS5 for full-text search
CREATE VIRTUAL TABLE entities_fts USING fts5(
    name, entity_type, observations,
    content=entities
);

# Run all tests (integration + HTTP transport)
cargo test

# Run only integration tests
cargo test --test integration

# Run only HTTP transport tests
cargo test --test http_transport

use memory_mcp_rs::{graph::Entity, manager::KnowledgeGraphManager};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = KnowledgeGraphManager::new("graph.db".into())?;

    // Create entity
    manager.create_entities(vec![
        Entity {
            name: "Alice".to_string(),
            entity_type: "person".to_string(),
            observations: vec!["Works at Acme".to_string()],
        }
    ]).await?;

    // Search
    let results = manager.search_nodes(Some("Acme".to_string())).await?;
    println!("Found {} entities", results.entities.len());

    Ok(())
}