Power your agent
Instal dari penerbit. Bukan endpoint PlugMCP.
URL remote atau perintah di mesin Anda? Perbedaan kedua cara instal
Jalankan di PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
BukaDari penerbit
Episodic memory system for AI agents with vector search, exposed via MCP server.
Verified Performance: 65.9% R@10 on LoCoMo benchmark • Up to 74% on long conversations
Note: This project was developed using - an AI-powered development assistant.
Comprehensive memory management system for LLM agents implementing episodic, semantic. Built in Rust with MCP server support for Kiro CLI
Agent Memory RS stores interaction episodes with vector embeddings and retrieves them using cosine similarity search. Exposed as an MCP server with learn and search tools.
~/.memory-rs/workspaces/)┌─────────────────────────┐
│ MCP Client │
└───────────┬─────────────┘
│ stdio (JSON-RPC)
┌───────────▼─────────────┐
│ MCP Server │
│ ┌─────────┐ ┌────────┐ │
│ │ learn │ │ search │ │
│ └────┬────┘ └───┬────┘ │
└───────┼──────────┼──────┘
┌───────▼──────────▼──────┐
│ EpisodicMemoryStore │
│ ┌──────────────────┐ │
│ │ SQLite + vec0 │ │
│ │ (episodes table) │ │
│ │ (vector index) │ │
│ └──────────────────┘ │
└─────────────────────────┘
git clone https://github.com/yourusername/agent-memory-rs
cd agent-memory-rs
cargo build --release
# Start the server
./target/release/agent-memory-mcp my-workspace
Configure your AI assistant:
{
"mcpServers": {
"agent-memory": {
"command": "/path/to/agent-memory-mcp",
"args": ["my-workspace"],
"env": {
"MEMORY_MODEL": "bge"
}
}
}
}
Configuration Options:
Model Selection:
bge (BGE-Small) - Best quality/speed balance, 384 dims, ~33MB ⭐ Recommendednomic (Nomic Embed) - Best for long context (8K tokens), 768 dims, ~138MBminilm (MiniLM) - Fastest, 384 dims, ~23MBAvailable MCP Tools:
@memory/learn - Store new memories@memory/search - Search across all memory typesRun the MCP server as a standalone HTTP service to share memory across devices on your network:
# Start HTTP server
./target/release/agent-memory-mcp --http 0.0.0.0:8230 my-workspace
Any MCP client that supports HTTP transport can connect directly:
{
"mcpServers": {
"agent-memory": {
"url": "http://server-ip:8230/mcp"
}
}
}
This is useful when you want a single memory database shared across multiple machines — run the server on one device (e.g. a Raspberry Pi or home server) and connect from anywhere on your network.
For environments without native HTTP MCP support, a agent-memory-proxy binary is included that bridges stdio ↔ HTTP:
{
"mcpServers": {
"agent-memory": {
"command": "/path/to/agent-memory-proxy",
"args": ["--remote", "http://server-ip:8230/mcp"]
}
}
}
Workspace Isolation: Each workspace has its own isolated database. Memories are NOT shared between workspaces.
Database Location:
~/.memory-rs/workspaces/
├── prime-sde-workspace/
│ └── memory.db # All memories for this workspace
├── my-project/
│ └── memory.db # Separate isolated memories
└── default/
└── memory.db # Default workspace
Workspace Naming:
["workspace-name"]<hash>-<dirname>
/path/to/workspace/myproject → a1b2c3d4-myprojectData Persistence:
~/.memory-rs/ loses all memoriesModel Cache: Models are downloaded once and cached in the standard HuggingFace cache:
~/.cache/huggingface/hub/
├── models--BAAI--bge-small-en-v1.5/
├── models--nomic-ai--nomic-embed-text-v1/
└── models--sentence-transformers--all-MiniLM-L6-v2/
# Create workspace
cargo run --bin agent-memory-cli workspace create --name my-project --path /path/to/project
# List workspaces
cargo run --bin agent-memory-cli workspace list
# Store episode
cargo run --bin agent-memory-cli store --workspace 1 --type user_query --context "How do I use Rust?" --outcome "Provided tutorial" --valence 0.8
# Query memories
cargo run --bin agent-memory-cli query --workspace 1 "rust programming" --limit 10
# Check system health
cargo run --bin agent-memory-cli stats --workspace 1
use agent_memory_rs::services::MemoryManager;
use agent_memory_rs::storage::Database;
// Initialize
let db = Database::new("memory.db")?;
let manager = MemoryManager::new(db.clone());
// Store episode
manager.store_episode(
1, // workspace_id
"user_query",
serde_json::json!({"query": "How do I use Rust?"}),
Some("Provided Rust tutorial"),
Some(0.8), // positive valence
)?;
// Search memories
let results = manager.retrieve("rust programming", 1, 10)?;
The repository includes a skill for AI agents using Kiro CLI:
Location: skill/agent-memory/SKILL.md
Add to your agent configuration:
{
"resources": [
"skill:///path/to/agent-memory-rs/skill/agent-memory/SKILL.md"
]
}
What the skill provides:
@memory/learn vs @memory/searchThe skill is loaded on-demand, providing guidance only when needed without consuming context at startup.
MemoryManager (Facade)
├── EpisodicMemoryStore - Raw interaction events
└── HybridRetrievalEngine - BM25 + Vector search
Built with SOLID principles:
Arc<Mutex<Connection>># Run all tests
cargo test
# Run integration tests only
cargo test --test '*'
# Run with output
cargo test -- --nocapture
Test Coverage: 29 tests covering full lifecycle
Based on modern AI agent memory research:
See Design Rationale for complete references.
sqlite-vec extensionLicensed under either of:
at your option.
Contributions welcome! Please read our contributing guidelines first.
Inspired by cognitive science research on human memory systems and modern AI agent architectures.
memory-cli prune --workspace 1 --dry-run
## 🧪 Testing
```bash
# Run all tests
cargo test
# Run integration tests only
cargo test --test '*'
# Run with output
cargo test -- --nocapture
Test Coverage: 29 tests covering full lifecycle
src/
├── services/ # 6 core services
├── storage/ # Database and memory store
├── traits/ # 5 SOLID traits
├── models/ # DTOs and types
├── cli/ # CLI commands
└── mcp/ # MCP server
tests/ # 16 integration test files
docs/ # 5 documentation files
# Development build
cargo build
# Release build (optimized)
cargo build --release
# Build MCP server only
cargo build --bin memory-rs-mcp --release
cargo test before committingMIT OR Apache-2.0
Built with:
Status: Production-ready ✅ Tests: 44 passing ✅ Documentation: Complete ✅ }
#### Search (Query Memories)
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "search",
"arguments": {
"query": "programming languages",
"workspace_id": 1,
"limit": 5
}
}
}
Response:
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"results": [
{
"memory_id": 42,
"text": "Rust is a systems programming language...",
"similarity_score": 0.92,
"combined_score": 0.88,
"importance_score": 0.8,
"tags": "rust,programming",
"created_at": "2026-01-30T22:00:00Z"
}
],
"count": 1
}
}
┌─────────────────────────────────────────────────────────────┐
│ CLI Tool │
└──────────────────────────┬──────────────────────────────────┘
│ stdio (JSON-RPC 2.0)
┌──────────────────────────▼──────────────────────────────────┐
│ MCP Server │
│ ┌────────────────┐ ┌────────────────┐ │
│ │ Learn Tool │ │ Search Tool │ │
│ └────────┬───────┘ └────────┬───────┘ │
└───────────┼──────────────────┼─────────────────────────────┘
│ │
┌───────────▼──────────────────▼─────────────────────────────┐
│ Memory System │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ FastEmbedder │ │ Memory Store │ │
│ │ (MiniLM/Nomic) │ │ (SQLite+vec) │ │
│ └──────────────────┘ └──────────────────┘ │
└─────────────────────────────────────────────────────────────┘
│ │
┌───────────▼──────────────────▼─────────────────────────────┐
│ Workspace Manager │
│ ~/.memory-rs/workspaces/ │
│ ├── project-a/memory.db │
│ ├── project-b/memory.db │
│ └── project-c/memory.db │
└─────────────────────────────────────────────────────────────┘
Storage Layer (src/storage/)
schema.rs: Database schema with sqlite-vec integrationmemory_store.rs: CRUD operations and vector searchMemory System (src/memory_system.rs)
MCP Server (src/mcp/)
server.rs: JSON-RPC 2.0 stdio transporttools.rs: Learn and Search tool implementationsWorkspace Manager (src/workspace.rs)
Embedder (src/embedder.rs)
Choose your embedding model based on your needs:
Configure in code:
use memory_rs::{WorkspaceManager, ModelType};
let manager = WorkspaceManager::new(ModelType::BgeSmall)?;
Workspaces are stored in ~/.memory-rs/workspaces/ by default:
use memory_rs::WorkspaceManager;
let manager = WorkspaceManager::new(ModelType::MiniLM)?;
// Create or get workspace
let system = manager.get_or_create_workspace("my-project")?;
// List all workspaces
let workspaces = manager.list_workspaces()?;
// Delete workspace
manager.delete_workspace("old-project")?;
Run all tests:
cargo test
Run specific test suites:
# Storage tests
cargo test --lib storage
# MCP server tests
cargo test --lib mcp
# Workspace tests
cargo test --lib workspace
workspaces
id: Primary keyname: Workspace name (unique)path: Filesystem pathcreated_at: Timestampagents
id: Primary keyworkspace_id: Foreign key to workspacesname: Agent namecreated_at: Timestampmemories
id: Primary keyworkspace_id: Foreign key to workspacesagent_id: Optional foreign key to agentstext: Memory contenttags: Comma-separated tagsimportance_score: Float 0-1access_count: Usage trackinglast_accessed: Timestampconversation_id: Optional conversation groupingparent_memory_id: Optional memory hierarchyuser_feedback: Optional feedback textcreated_at, updated_at: Timestampsvec0 (virtual table)
memory_id: Foreign key to memoriesembedding: Float vector (384 or 768 dimensions)idx_memories_workspace: Fast workspace filteringidx_memories_agent: Fast agent filteringidx_memories_importance: Importance-based queriesidx_memories_created: Temporal queriesidx_memories_conversation: Conversation groupingCombines semantic similarity (70%) with importance score (30%):
use memory_rs::storage::SearchFilters;
let filters = SearchFilters {
workspace_id: Some(1),
agent_id: Some(5),
min_importance: Some(0.5),
max_importance: Some(1.0),
conversation_id: Some("conv-123".to_string()),
..Default::default()
};
let results = system.search("query text", &filters, 10)?;
Input Schema:
{
"type": "object",
"properties": {
"text": {"type": "string", "description": "The text to remember"},
"workspace_id": {"type": "integer", "description": "Workspace ID"},
"agent_id": {"type": "integer", "description": "Optional agent ID"},
"tags": {"type": "string", "description": "Optional comma-separated tags"},
"importance_score": {"type": "number", "description": "Importance score 0-1"},
"conversation_id": {"type": "string", "description": "Optional conversation ID"}
},
"required": ["text", "workspace_id"]
}
Input Schema:
{
"type": "object",
"properties": {
"query": {"type": "string", "description": "Search query"},
"workspace_id": {"type": "integer", "description": "Optional workspace ID filter"},
"agent_id": {"type": "integer", "description": "Optional agent ID filter"},
"min_importance": {"type": "number", "description": "Minimum importance score"},
"max_importance": {"type": "number", "description": "Maximum importance score"},
"conversation_id": {"type": "string", "description": "Optional conversation ID filter"},
"limit": {"type": "integer", "description": "Maximum results (default 10, max 100)"}
},
"required": ["query"]
}
See examples/ directory for complete examples:
mcp_server.rs: Full MCP server implementationContributions welcome! Please:
cargo testMIT OR Apache-2.0
Built with ❤️ in Rust
Comprehensive memory management system for LLM agents implementing episodic, semantic. Built in Rust with MCP server support for Kiro CLI
Tool
Belum ada daftar tool. Server remote mendapatkannya setelah pemeriksaan kesehatan pertama.
FAQ
Salin konfigurasi stdio untuk Cursor, Claude Desktop, Claude Code, atau VS Code di halaman ini. Konfigurasi ini memakai instalasi dari penerbit, bukan proxy PlugMCP.
Tidak ada variabel lingkungan wajib yang tercantum di catatan ini.
Agent Memory Rs berjalan secara lokal melalui stdio.
Terakhir diperiksa 2026-10-28. Comprehensive memory management system for LLM agents implementing episodic, semantic. Built in Rust with MCP server support for Kiro CLI
