Skip to main content
Glama

raggy-mcp

MCP server that gives every AI agent a universal brain -- centralized memory and knowledge via Raggy. One brain, all agents.

How agents use Raggy

Starting in 0.3.0, raggy-mcp ships with a built-in agent protocol that teaches any connected client how to use the memory tools correctly. The protocol is advertised through the MCP instructions field on initialization, so compatible clients (Claude Desktop, Cursor, Zed, Windsurf, Claude Code, and most modern MCP editors) pass it to the underlying LLM automatically.

You no longer need to paste memory rules into SOUL.md, AGENTS.md, or CLAUDE.md -- connect the server and every agent knows the rules:

  • Recall at the start of every session (once), via raggy_context

  • Auto-capture decisions, errors, preferences, insights as they happen

  • Link related memories into a knowledge graph with raggy_link

  • Use raggy_timeline for "what did we do today" and raggy_threads for "what was in my last session"

  • Respect "forget that" / "don't save that" immediately

See PROTOCOL.md for the full text, and for manual install instructions if your client doesn't yet support MCP instructions.

Related MCP server: Recall

Features

  • Universal memory protocol: Auto-loaded agent rules via MCP instructions

  • Capture & Recall: Store decisions, errors, insights, snippets, research, and bookmarks that persist across sessions and agents

  • Context bootstrap: raggy_context loads relevant prior-session memories at the start of every conversation

  • Timeline & Threads: Chronological memory and per-session grouping for temporal queries

  • Knowledge graph: Explicit links between memories (caused_by, resolved_by, supersedes, refines, contradicts, related_to, follows_from, part_of)

  • Private sources: Upload files, URLs, and long-form content as searchable private knowledge

  • Forget: Remove outdated or redact-while-preserving memories when they are no longer needed

Installation

Add to your Claude Code configuration:

{
  "mcpServers": {
    "raggy": {
      "command": "npx",
      "args": ["-y", "raggy-mcp"]
    }
  }
}

Manual installation

npm install -g raggy-mcp

Then add to your Claude Code configuration:

{
  "mcpServers": {
    "raggy": {
      "command": "raggy-mcp"
    }
  }
}

Configuration

API Key (optional)

For Pro tier access (200 searches/day), set your API key:

# Via environment variable
export RAGGY_API_KEY=rgy_live_xxxxx

# Or create config file
mkdir -p ~/.claude/raggy
echo '{"apiKey": "rgy_live_xxxxx"}' > ~/.claude/raggy/config.json

Free tier (20 searches/day) works without an API key.

Tools

All tools follow the agent protocol loaded automatically at connect time (see PROTOCOL.md).

Memory writing

  • raggy_capture -- Structured auto-capture with rich metadata. Use for decisions, errors, preferences (tag as ["preference"]), insights, snippets, and research. Requires content_type and importance.

  • raggy_remember -- Simple unstructured note. Prefer raggy_capture when you have a clear type.

  • raggy_link -- Connect two memories in the knowledge graph using one of: caused_by, resolved_by, supersedes, refines, contradicts, related_to, follows_from, part_of.

  • raggy_forget -- Delete or redact a memory. Call when the user says "forget that" or "don't save that".

Memory reading

  • raggy_context -- Mandatory first action of every session. Loads relevant memories from prior sessions based on project/technologies/query.

  • raggy_recall -- Targeted semantic search. Use only as a follow-up lookup mid-session; don't call twice per question.

  • raggy_timeline -- Chronological browse. Use for "what did we do today/yesterday/last week" questions.

  • raggy_threads -- Session-based browse. Use for "what was in my last session" questions.

Private sources (requires API key)

  • raggy_upload -- Upload files, URLs, or long-form content as a searchable private source.

  • raggy_private_sources -- List uploaded sources.

  • raggy_delete_source -- Delete an uploaded source by ID.

Pricing

Tier

Searches

Features

Free

20/day

Detection, semantic search

Pro

200/day

Priority support

Enterprise

Custom

Private docs, SSO, SLA

Development

# Install dependencies
npm install

# Build
npm run build

# Run locally
npm start

License

MIT

Available Tools

11 tools
raggy_captureA

Auto-capture structured memory. Use for: decisions (content_type="decision"), errors+fixes ("error"), preferences ("note" + tags:["preference"]), insights ("insight"), snippets ("snippet"), research ("research"). Set importance: high for decisions/errors/prefs, medium for insights/snippets. Always include source_app + capture_context.agent_id.

Inputs: content (required), url, name, tags, +6 more.

raggy_contextA

MANDATORY FIRST ACTION of every session. Call ONCE before answering the first user message with their initial request as the query. Loads relevant memories from prior sessions. Do not make a second call unless this returned empty and you need a targeted lookup (then use raggy_recall).

Inputs: files, limit, query, project, +3 more.

raggy_delete_sourceA

Delete an uploaded private knowledge base source by ID. Use when the user asks to remove a specific source. For individual memories use raggy_forget instead. Get the ID via raggy_private_sources. Requires API key.

Inputs: sourceId (required).

raggy_forgetA

Call immediately when the user says "forget that", "don't save that", or "delete that memory". Use mode="delete" to remove entirely or mode="redact" to preserve the graph node but strip content. Not for uploaded sources — use raggy_delete_source for those.

Inputs: memory_id (required), mode.

raggy_private_sourcesA

List uploaded private knowledge base sources (files/URLs ingested via raggy_upload). Use when the user asks "what sources have I uploaded" or to find a source ID for deletion. Requires API key.

Inputs: no named parameters.

raggy_recallA

Targeted semantic search over memories. Only use AFTER raggy_context at session start has returned nothing relevant, or for a specific follow-up lookup mid-session. Do NOT call twice per question. For time-based queries use raggy_timeline.

Inputs: query (required), tags, limit, source_app.

raggy_rememberA

Save a simple, unstructured note. Prefer raggy_capture for anything with a clear type (decision/error/insight/snippet). Only use raggy_remember for free-form notes where metadata adds no value.

Inputs: content (required), url, name, tags.

raggy_threadsA

Use for session-based queries like "what was in my last session" or "what did we discuss in that conversation about X". action="list" browses recent sessions; action="get" retrieves all memories for one session_id.

Inputs: limit, since, action, session_id, +1 more.

raggy_timelineA

Use for time-based queries like "what did we work on today/yesterday/last week". Pass since as a relative window (e.g. "24h", "7d") or ISO date. Do NOT use raggy_recall for temporal questions — this is the right tool.

Inputs: limit, since, until, session_id, +2 more.

raggy_uploadA

Upload files, URLs, or long-form content as a private knowledge base source. Use for documents, articles, or reference material the user wants indexed and searchable. For short notes/thoughts use raggy_capture instead. Requires API key.

Inputs: name (required), url, content, category.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 11 tools

    Disambiguation4/5

    Tools are largely distinct, but raggy_remember and raggy_capture both create memories, and raggy_context and raggy_recall both handle memory retrieval. Descriptions do separate them well via structured vs unstructured capture and session-start vs targeted lookup, so confusion is unlikely in practice.

    Naming Consistency3/5

    All tools share the raggy_ prefix and snake_case formatting, but naming style is mixed: upload, remember, capture, recall, forget, and link are verbs, while context, timeline, threads, and private_sources are noun phrases. There is no consistent verb_noun pattern.

    Tool Count5/5

    11 tools is well-scoped for a memory/knowledge server covering ingestion, retrieval, deletion, graph linking, and session introspection. Each tool has a clear role and the count feels appropriate rather than bloated or thin.

    Completeness4/5

    The set covers upload/list/delete for private sources, capture/remember/forget for memories, context/recall/timeline/threads for retrieval, and link for graph relationships. The main gap is no explicit update/edit operation for a memory, though supersedes links and forget redaction partially address that.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Provides persistent long-term memory for AI agents through semantic search and automated knowledge graph extraction. It enables agents to store, recall, and reason over facts, preferences, and relationships across multiple conversations and sessions.
      14
      15 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Provides persistent, cross-session memory for AI agents, allowing them to store and automatically retrieve information across different conversations and sessions without repeating context.
      8 npm
      178
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides persistent knowledge graph memory for AI agents, enabling them to store, recall, and query facts about people, projects, and relationships across sessions.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables persistent, graph-based memory for AI agents, allowing them to store, traverse, and recall relationships between facts, decisions, and context across sessions for efficient reasoning and reduced token usage.
      MIT