context-mcp 0.1.1

MCP server for context management, RAG processing, and temporal reasoning - inspired by memory-gate patterns
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
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

# context-mcp

[![Crates.io](https://img.shields.io/crates/v/context-mcp.svg)](https://crates.io/crates/context-mcp)
[![Documentation](https://docs.rs/context-mcp/badge.svg)](https://docs.rs/context-mcp)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

MCP server for context management, temporal metadata, and lightweight retrieval/RAG plumbing.

This crate is intended to be a "memory service" for agents: store/retrieve context items with timestamps and metadata, and support simple query/retrieval patterns.

## Features

- **Multi-tier Storage**: In-memory (LRU), cache, and disk persistence
- **Temporal Reasoning**: Timestamps and age tracking for context relevance
- **RAG Processing**: CPU-optimized retrieval-augmented generation support
- **MCP Protocol**: Full compatibility with VS Code, Copilot, and other MCP clients
- **Safe Input Handling**: Integrates with security-mcp for screened inputs

## Status

Alpha / under active development. APIs and tool names may change.

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
context-mcp = "0.1.0-alpha.1"
```

## Usage

### As a Library

```rust
use context_mcp::{ContextStore, StorageConfig, Context, ContextDomain};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create storage configuration
    let config = StorageConfig {
        memory_cache_size: 1000,
        enable_persistence: true,
    };

    // Create context store
    let store = ContextStore::new(config)?;

    // Store some context
    let ctx = Context::new("This is some important information", ContextDomain::Code);
    let id = store.store(ctx).await?;

    // Retrieve it
    let retrieved = store.get(&id).await?;
    println!("Retrieved: {}", retrieved.content);

    Ok(())
}
```

### As an MCP Server

Run as HTTP server:
```bash
context-mcp --host 127.0.0.1 --port 3000
```

Run as stdio transport:
```bash
context-mcp --stdio
```

## What It Does Today (Code-Backed)

- Runs an MCP-compatible JSON-RPC server over HTTP/WebSocket.
- Stores context with IDs, domains, timestamps, and metadata.
- Supports tiered storage primitives (in-memory + on-disk via `sled`).
- Provides MCP tools for context storage, retrieval, and querying.
- Basic temporal reasoning with time-based filtering.

## What It Does Not Do Yet

- Production-grade embedding/vector search.
- Full RAG pipelines with reliable chunking/citation policies.
- Strong consistency guarantees across distributed replicas.
- Advanced query capabilities (semantic search, etc.).

## Architecture

```
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   MCP Client    │    │  Context Gateway │    │ Storage Layer   │
│                 │    │                  │    │                 │
│ • VS Code       │◄──►│ • Store/Retrieve │◄──►│ • In-Memory LRU │
│ • Copilot       │    │ • Temporal Query │    │ • Sled Disk DB  │
│ • CLI Tools     │    │ • RAG Processing │    │ • Vector Index  │
└─────────────────┘    └──────────────────┘    └─────────────────┘
```

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and contribution guidelines.

## License

Licensed under the MIT License. See [LICENSE](LICENSE) for details.