MemoryStackMemoryStack/Documentation

    Model Context Protocol Integration

    Give your AI applications persistent, adaptive memory through a standardized protocol. Works with Claude Desktop, Cursor, and any MCP-compatible client.

    Production Ready14 Powerful ToolsAdaptive Learning

    What is Model Context Protocol?

    Model Context Protocol (MCP) is an open standard that enables AI applications to securely connect to external data sources and tools. Think of it as a universal adapter that lets any AI assistant access your systems through a standardized interface.

    Without MCP

    AI applications are isolated, with no memory between sessions. Every conversation starts from scratch.

    With Neural Weave MCP

    AI remembers context, learns patterns, and provides personalized responses across all sessions and applications.

    Why Neural Weave + MCP?

    Unlike traditional memory systems that simply store and retrieve facts, Neural Weave implements a complete cognitive cycle that mirrors human memory processes.

    Adaptive Learning

    Automatically discovers patterns, tracks preference evolution, and generates insights from your data.

    Contradiction Resolution

    Automatically detects conflicting information and helps resolve inconsistencies in your memory system.

    Enterprise Ready

    Complete multi-tenancy, GDPR compliance, and isolated memory spaces for B2B applications.

    Real-World Example

    Traditional Memory System:

    "I remember you like coffee"

    Neural Weave OS:

    "I learned you have a morning coffee routine between 7:45-8:15am on weekdays. Your preference evolved from tea to coffee over the past month. Would you like me to suggest your usual order at 7:50am tomorrow?"

    Quick Start Guide

    1

    Get Your API Key

    1. Navigate to your Neural Weave dashboard
    2. Go to Dashboard → API Keys
    3. Click Generate New Key
    4. Copy the key (format: nw_xxxxxxxxxxxxx)
    5. Store it securely - you won't see it again!
    2

    Configure Your AI Client

    No installation required! The MCP server is automatically downloaded via NPX when you configure your client.

    For Claude Desktop

    Add to your Claude config file:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
    • Linux: ~/.config/Claude/claude_desktop_config.json
    {
      "mcpServers": {
        "neural-weave": {
          "command": "npx",
          "args": ["-y", "neural-weave-mcp"],
          "env": {
            "NEURAL_WEAVE_API_KEY": "nw_your_api_key_here"
          }
        }
      }
    }

    Note: The -y flag automatically accepts the NPX prompt. The package will be downloaded and cached on first use.

    For Cursor

    Open Cursor Settings → MCP Servers and add:

    {
      "neural-weave": {
        "command": "npx",
        "args": ["-y", "neural-weave-mcp"],
        "env": {
          "NEURAL_WEAVE_API_KEY": "nw_your_api_key_here"
        }
      }
    }

    For Kiro IDE

    Add to .kiro/settings/mcp.json:

    {
      "mcpServers": {
        "neural-weave": {
          "command": "npx",
          "args": ["-y", "neural-weave-mcp"],
          "env": {
            "NEURAL_WEAVE_API_KEY": "nw_your_api_key_here"
          }
        }
      }
    }
    3

    Test the Integration

    Restart your AI client and try these prompts:

    Create a memory:

    "Remember that I prefer working in the morning between 8-11am"

    Search memories:

    "What do you know about my work preferences?"

    Discover patterns:

    "Analyze my memory patterns from the past week"

    Available MCP Tools

    Neural Weave exposes 14 powerful tools through the MCP protocol. Your AI client can automatically discover and use these tools based on context.

    Core Memory Operations

    create_memory

    Store new memories with automatic fact extraction, embedding generation, importance scoring, and contradiction detection.

    {
      "content": "I prefer TypeScript over JavaScript for type safety",
      "memory_type": "preference",  // Optional: fact, preference, observation, habit, skill, goal, insight
      "confidence": 0.9,            // Optional: 0-1 confidence score
      "user_id": "alice_123",       // Optional: For B2B multi-tenancy
      "metadata": {                 // Optional: Additional context
        "source": "conversation",
        "category": "programming"
      }
    }

    search_memories

    Hybrid search combining vector similarity and text matching for best accuracy.

    {
      "query": "programming language preferences",
      "limit": 10,                  // Optional: Max results (1-50)
      "mode": "hybrid",             // Optional: hybrid, vector, or text
      "memory_type": "preference",  // Optional: Filter by type
      "min_confidence": 0.7         // Optional: Minimum confidence threshold
    }

    list_memories

    Browse memories with pagination and filtering.

    {
      "limit": 20,                  // Optional: Results per page (1-100)
      "order": "desc",              // Optional: asc or desc
      "memory_type": "fact",        // Optional: Filter by type
      "cursor": "next_page_token"   // Optional: For pagination
    }

    update_memory / delete_memory

    Modify or remove memories with GDPR-compliant soft delete support.

    Advanced Intelligence

    reflect_on_memories

    Discover patterns, track preference evolution, and generate insights from your memory history.

    {
      "time_window_days": 7,        // Optional: Days to analyze (1-90)
      "analysis_depth": "deep",     // Optional: shallow or deep
      "dry_run": false,             // Optional: Preview without storing
      "min_pattern_strength": 0.7   // Optional: Threshold (0-1)
    }

    Example Output:

    "Pattern: User has morning coffee routine between 7:45-8:15am on weekdays (strength: 0.92)"

    get_contradictions

    Find unresolved contradictions between memories automatically.

    // Returns conflicting memories with explanations
    {
      "contradictions": [
        {
          "memory_a": { "content": "I like coffee", "confidence": 0.6 },
          "memory_b": { "content": "I prefer tea", "confidence": 0.9 },
          "contradiction_type": "direct",
          "explanation": "Conflicting beverage preferences"
        }
      ]
    }

    resolve_contradiction

    Resolve conflicts with strategies: keep_new, keep_old, merge, or keep_both.

    consolidate_memories

    Merge duplicate or highly similar memories to optimize storage and reduce redundancy.

    Analytics & Management

    get_memory_stats

    Get statistics about memory usage, access patterns, and system health.

    get_memory_lineage

    View complete provenance chain showing how memories were created, modified, or derived.

    export_memories / import_memories

    Backup and restore memories in JSON or CSV format for data portability.

    Real-World Use Cases

    Personal AI Assistant

    User:

    "Remember that I prefer working in the morning"

    AI:

    [Uses create_memory to store preference]

    User (next day):

    "What time do I usually work?"

    AI:

    [Uses search_memories and reflect_on_memories]
    "You have a consistent morning work routine between 8am-12pm"

    Customer Support Bot

    Agent:

    "Customer prefers email communication"

    System:

    [Stores with user_id: "customer_123"]

    Agent (later):

    "What do we know about this customer?"

    System:

    [Searches memories for customer_123]
    "Prefers email, had issue with billing last month, timezone: PST"

    Learning Assistant

    Student:

    "I'm learning Python"

    System:

    [Stores as skill development memory]

    After 2 weeks:

    "What should I learn next?"

    System:

    [Reflection discovers skill progression]
    "You've progressed from beginner to intermediate. Focus on async/await next."

    Development Assistant

    Developer:

    "Remember our API uses JWT authentication"

    AI:

    [Stores as project fact]

    Developer (later):

    "How do we handle authentication?"

    AI:

    [Retrieves project context]
    "Your API uses JWT authentication. Here's the implementation pattern..."

    How It Works

    Simple integration flow from your AI client to Neural Weave's memory system:

    1

    Your AI Client

    Claude Desktop, Cursor, Kiro IDE, or any MCP-compatible application.

    ↓ MCP Protocol

    2

    Neural Weave MCP Server

    Automatically installed NPM package that handles all communication with Neural Weave.

    ↓ Secure Connection

    3

    Neural Weave Memory System

    Stores, retrieves, and learns from your memories with adaptive intelligence.

    Security & Privacy

    API Key Authentication

    All requests require valid API key with Bearer token authentication. Keys can be revoked instantly.

    Data Isolation

    Complete multi-tenancy with isolated memory spaces. B2B users have zero data leakage between end users.

    GDPR Compliance

    Soft delete by default for data recovery. Hard delete available for permanent removal when required.

    Rate Limiting

    Automatic usage limits per plan tier. Monitor usage in real-time through the dashboard.

    HTTPS Only

    All API communication is encrypted. No plain-text transmission of sensitive data.

    Audit Logging

    Complete provenance tracking for every memory. Know exactly when and how data was created or modified.

    Additional Resources

    Ready to Get Started?

    Give your AI applications the gift of adaptive memory. Start building with Neural Weave MCP today.