rustmem 0.2.0

A lightweight Rust alternative to mem0 — long-term memory for AI agents
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

mod config;
mod embedding;
mod extract;
mod graph;
mod mcp;
mod memory;
mod server;
mod store;

use clap::{Parser, Subcommand};
use tracing::info;

#[derive(Parser)]
#[command(name = "rustmem", about = "Long-term memory for AI agents", version)]
struct Cli {
    #[arg(short, long, global = true)]
    config: Option<String>,

    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Start the memory API server
    Server,
    /// Add a memory from the command line
    Add {
        #[arg(short, long)]
        user: String,
        text: String,
    },
    /// Search memories
    Search {
        #[arg(short, long)]
        user: String,
        query: String,
        #[arg(short, long, default_value_t = 10)]
        limit: usize,
    },
    /// List all memories for a user
    List {
        #[arg(short, long)]
        user: String,
    },
    /// Show graph relations for a user
    Graph {
        #[arg(short, long)]
        user: String,
    },
    /// Start MCP server over stdio (for Claude Code / Cursor)
    Mcp,
    /// Reset all memories for a user
    Reset {
        #[arg(short, long)]
        user: String,
    },
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();

    // MCP mode: logs MUST go to stderr (stdout is JSON-RPC transport)
    let is_mcp = matches!(cli.command, Command::Mcp);
    if is_mcp {
        tracing_subscriber::fmt()
            .with_env_filter(
                tracing_subscriber::EnvFilter::from_default_env()
                    .add_directive("rustmem=info".parse()?),
            )
            .with_writer(std::io::stderr)
            .with_ansi(false)
            .init();
    } else {
        tracing_subscriber::fmt()
            .with_env_filter(
                tracing_subscriber::EnvFilter::from_default_env()
                    .add_directive("rustmem=info".parse()?),
            )
            .init();
    }

    let cfg = config::AppConfig::load(cli.config.as_deref())?;

    match cli.command {
        Command::Mcp => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            mcp::run(mem).await
        }
        Command::Server => {
            info!("Starting rustmem server on {}", cfg.server.listen_addr());
            let mem = memory::MemoryManager::new(&cfg).await?;
            server::run(cfg, mem).await
        }
        Command::Add { user, text } => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            let results = mem.add(&user, &text).await?;
            for r in &results {
                println!("[{}] {} → {}", r.event, r.id, r.text);
            }
            if results.is_empty() {
                println!("No facts extracted.");
            }
            Ok(())
        }
        Command::Search { user, query, limit } => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            let results = mem.search(&user, &query, limit).await?;
            if results.is_empty() {
                println!("No memories found.");
            }
            for r in &results {
                println!("[{:.3}] {} — {}", r.score, r.id, r.text);
            }
            Ok(())
        }
        Command::List { user } => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            let records = mem.get_all(&user).await?;
            if records.is_empty() {
                println!("No memories for user '{user}'.");
            }
            for r in &records {
                println!("{} | {} | {}", r.id, r.updated_at, r.text);
            }
            Ok(())
        }
        Command::Graph { user } => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            let relations = mem.get_graph(&user).await?;
            if relations.is_empty() {
                println!("No graph relations for user '{user}'.");
            }
            for r in &relations {
                println!(
                    "{} --[{}]--> {} (mentions: {})",
                    r.source, r.relation, r.destination, r.mentions
                );
            }
            Ok(())
        }
        Command::Reset { user } => {
            let mem = memory::MemoryManager::new(&cfg).await?;
            let count = mem.reset(&user).await?;
            println!("Deleted {count} memories for user '{user}'.");
            Ok(())
        }
    }
}