Mesh

High-speed shared semantic & hybrid memory layer for AI agents.

When one agent learns something, every other agent can recall it — by meaning, keyword, or exact identifier.

The Problem

Every AI agent starts each session with amnesia. Claude in your terminal doesn't know what Claude in your editor discovered. Your coding agent cannot access what your review agent found. Every agent repeats work already done.

The Solution

Mesh provides persistent, shared agent memory with:

• 3-Stage Hybrid Search: Dense Vector SIMD Cosine (cache.matrix @ q_vec in <0.1 ms) + SQLite FTS5 BM25 + Exact Token Overlap.
• Unified Local Storage: Pure SQLite WAL per namespace — zero external database daemons, zero multi-process synchronization issues.
• Smart Deduplication & Contradiction Tracking: Identical facts are reinforced in-place; contradictory facts are flagged for review without silent data loss.
• Time-to-Live (TTL) Confidence Decay: Ephemeral facts gradually decay towards staleness.
• Multi-Interface: MCP Server (10 tools for Claude Desktop, Cursor, Windsurf), Web Dashboard, HTTP REST API, and CLI.

Quickstart

1. Installation

pip install mesh-context-layer

2. Python SDK

from mesh import Mesh

# Agent 1: Learns an architecture constraint
agent_a = Mesh(namespace="checkout-service", agent_id="backend-agent")
agent_a.learn(
    "Production PostgreSQL 16 database runs on port 5432 with pgBouncer connection pooling",
    memory_type="fact",
    tags=["db", "postgres", "prod"]
)

# Agent 2: Recalls it without direct communication
agent_b = Mesh(namespace="checkout-service", agent_id="frontend-agent")
results = agent_b.recall("what port does production postgres use?", n=3)

for r in results:
    print(f"[{r['similarity']:.2f}] {r['content']} (from {r['source_agent']})")

MCP Server (Claude Desktop, Cursor & Windsurf)

Mesh provides 10 MCP tools directly to your AI agents.

Claude Desktop Configuration

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "mesh": {
      "command": "mesh-server"
    }
  }
}

Cursor Configuration

Create .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "mesh": {
      "command": "mesh-server"
    }
  }
}

Available MCP Tools

Web Dashboard

Launch the zero-build local visualizer:

mesh-dashboard --namespace checkout-service --port 7433

Open http://localhost:7433 in your browser. Features:

• Real-Time Hybrid Search with instant score breakdowns.
• Contradiction Inspector: Review and resolve flagged memory conflicts.
• Memory Gaps & Patterns: See queries agents asked that had low recall similarity.
• Audit Stream: Real-time log of agent reads and writes.
• Keyboard Shortcuts: / to focus search, n to create a memory, Esc to close modals.

Memory Types

HTTP REST API

Start the local background server:

mesh-http --port 7701

From any terminal, script, or language:

# Store a memory
curl -s -X POST http://localhost:7701/learn \
  -H "Content-Type: application/json" \
  -d '{"content": "Auth service requires JWT RS256 signatures", "memory_type": "instruction"}'

# Recall memories
curl -s -X POST http://localhost:7701/recall \
  -H "Content-Type: application/json" \
  -d '{"query": "auth JWT algorithm", "n": 3}'

# Format context directly into agent system prompts
curl -s -X POST http://localhost:7701/context \
  -H "Content-Type: application/json" \
  -d '{"count": 10, "format": "markdown"}'

Portability & Privacy

Privacy Flags

Mark sensitive memories as local_only=True to guarantee they are never exported or synced:

mesh.learn("Staging DB password: secret-pass", local_only=True, tags=["credentials"])

Backup & Restore

# Export all public memories to JSON
mesh-export backup.json --namespace checkout-service

# High-speed batch import (with automatic deduplication)
mesh-import backup.json --namespace checkout-staging --merge-strategy skip_existing

Detailed Changelog

v0.5.1 (Latest)

• High-Speed Batch Import/Export: import_namespace now commits all memories in a single atomic SQLite WAL transaction via upsert_batch() and utilizes O(1) in-memory vector cache ID lookups, removing N+1 database queries. Missing embeddings are computed in a single forward pass.
• MCP Stdio Redirection Safety: Added thread-safe stdout redirection to ensure print statements never corrupt stdio JSON-RPC payloads in Claude Desktop or Cursor.
• Optimized Context Generation: Streamlined single-pass context assembly for /context HTTP endpoint and mesh_context MCP tool with tag and memory type filtering.
• Fast-Path Registry: Added lockless fast-path lookups to the HTTP server's Mesh instance registry.
• Showcase Suite: Added examples/full_showcase.py verifying all 11 core engine stages end-to-end.
• Windows Console Resiliency: Safe UTF-8 console output handling preventing CP1252 character map errors.

v0.5.0

• ChromaDB Removal: Transitioned to a unified SQLite WAL + NumPy SIMD in-memory vector cache engine, eliminating external C++ dependencies, multi-database sync bugs, and heavy binary bloat.
• 3-Stage Hybrid Search: Combines Dense Cosine Similarity (<0.1 ms), SQLite FTS5 BM25 lexical ranking, and exact token overlap boosting.
• Automatic Deduplication Engine: Near-identical memories ($\ge 0.985$ similarity) reinforce existing records rather than creating duplicate rows.
• Contradiction Tracking: Conflicting statements ($\ge 0.82$ similarity with numeric/negation polarity changes) are stored and recorded in a contradiction log for review.
• Time-to-Live (TTL) & Confidence Decay: Linear time-based confidence decay for temporary facts.
• Full 10-Tool MCP Server: Complete tool suite for LLMs.
• Interactive Web Dashboard: Single-file dark/light UI with search, contradiction management, pattern analysis, and audit trails.
• Passive Capture & Daily Digests: Automated memory extraction from AI session logs (mesh-capture) and Markdown summary generation (mesh-digest).

License

MIT © billighost