mcp-memory 4.0.2

MCP server for knowledge graph memory — entities, relations, and observations in SQLite with FTS5 search, plus optional vector/semantic + hybrid search (usearch HNSW or IVF-Flat) with batch upsert, more-like-this, recommendations, and MMR diversification
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! `mcp-memory-vec` — a thin backward-compatible alias for the unified
//! `mcp-memory` server with vector search forced on.
//!
//! The two servers were merged: the knowledge-graph server now hosts the
//! `vector_*` / `hybrid_search` tools behind the `--vectors` flag (see
//! `src/server.rs`). This binary simply parses the same arguments and enables
//! vectors unconditionally, so existing `mcp-memory-vec` configs keep working.
//! New deployments can equivalently run `mcp-memory --vectors`.

use std::process::ExitCode;

use clap::Parser;
use tracing_subscriber::EnvFilter;

use mcp_memory::config::Config;
use mcp_memory::server::MCPServer;
use mcp_memory::{Args, Transport};

fn main() -> ExitCode {
    let mut args = Args::parse();
    // This binary is the vector-enabled entry point regardless of the flag.
    args.vectors = true;

    tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(&args.log_level)),
        )
        .init();

    mcp_memory::tls::ensure_crypto_provider();

    let config = match Config::from_args(&args) {
        Ok(c) => c,
        Err(e) => {
            tracing::error!("Configuration error: {e}");
            return ExitCode::FAILURE;
        }
    };
    let vec_config = args.vector_config();
    let bind = config.bind_addr.clone();
    let transport = config.transport;

    let rt = match tokio::runtime::Runtime::new() {
        Ok(rt) => rt,
        Err(e) => {
            tracing::error!("Failed to start tokio runtime: {e}");
            return ExitCode::FAILURE;
        }
    };

    let result = rt.block_on(async {
        let server = MCPServer::new(config, vec_config)?;
        match transport {
            Transport::Stdio => server.run_stdio().await,
            Transport::Tcp => server.run_tcp(&bind).await,
            Transport::Http => server.run_http(&bind).await,
        }
    });

    match result {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            tracing::error!("Server error: {e:?}");
            ExitCode::FAILURE
        }
    }
}