# Latency & Performance Benchmarks Source: https://docs.memwyre.tech/benchmarks Read the performance and latency benchmark report comparing Memwyre's retrieval with Mem0, Zep, and Supermemory. # How Memwyre Works Source: https://docs.memwyre.tech/how-it-works Understand the architectural concepts of Memwyre, including memory decay curves, graphs, profiles, and routing. Memwyre captures knowledge from your workflows, processes it using a hybrid vector-graph model, and delivers it on-demand to your AI tools via the **Model Context Protocol (MCP)**. ```mermaid theme={null} graph TD subgraph Capture ["1. Capture & Sync"] Browser[Browser Extension] -->|Web Clips & Chats| API IDE[IDE Integrations] -->|Active Files & Workspace| API Connectors[Connectors: Notion, GitHub, GDrive] -->|Knowledge Bases| API end subgraph Core ["2. Processing & Storage"] API[Memwyre API] --> Ingest[Ingestion Pipeline] Ingest --> Chunking[Semantic Chunking] Ingest --> Facts[Fact Extraction] Chunking --> VecDB[(Vector DB)] Facts --> Graph[(Hierarchical Entity Graph)] end subgraph Retrieve ["3. Context Delivery"] VecDB --> Hybrid[Hybrid Query Engine] Graph --> Hybrid Hybrid --> MCP[MCP Server] MCP -->|Dynamic Context Injection| Clients[Cursor / VS Code / Claude Code / Claude Desktop] end style Graph fill:#D97757,stroke:#fff,stroke-width:2px,color:#fff style MCP fill:#050614,stroke:#fff,stroke-width:2px,color:#fff ``` ## The Ingestion & Retrieval Lifecycle 1. **Capture** — Save text blocks, code snippets, Slack chats, or documentation from the browser extension, native connectors, or CLI. 2. **Ingest & Structure** — Incoming data is parsed. The system splits text into semantic chunks and uses LLMs to extract atomic facts (subject-predicate-object relationships), storing them in a hierarchical entity graph. 3. **Retrieve** — When you prompt your AI, Memwyre uses hybrid search (combining dense vector retrieval with graph traversal) to resolve exactly which projects, files, and rules apply to your query, serving them instantly. *** Here are the core concepts you need to know: ## 1. Capture Your Knowledge You save documents, articles, transcripts, or developer notes to your Memwyre vault. This can be done via: * **The Browser Extension** — Bookmark articles, chat logs, or text selections as you read. * **Integrations** — Automatically sync work directories and files. * **The API & CLI** — Send context directly from your terminal or custom scripts. *** ## 2. Auto-Updating Context Memwyre keeps your memories current. If you save a note that contradicts or updates a previous entry, the system automatically surfaces the most recent update. This prevents your AI tools from getting confused by outdated codebase guidelines, changed API endpoints, or stale project descriptions. *** ## 3. Dynamic Context Injection When you prompt a connected AI client (such as Cursor, VS Code, or Claude Desktop): 1. **Analysis** — Memwyre looks at your prompt to understand the topics and projects you are referring to. 2. **Selection** — It retrieves the most relevant guidelines, snippets, and project rules from your vault. 3. **Injection** — The context is formatted and appended to your prompt block in the background. The LLM receives the prompt with the exact context it needs to provide an accurate response. *** ## The Processing Pipeline When you save content to Memwyre, it moves through the following lifecycle stages before it becomes available to your AI tools: | Stage | Description | | :------------- | :---------------------------------------------------------------------------- | | **Queued** | The raw capture is received and queued for processing. | | **Extracting** | Boilerplate noise, headers, footers, and page scripts are stripped. | | **Indexing** | Semantic vector profiles are generated and entity relationships are resolved. | | **Ready** | The memory is fully active and searchable for prompt context injection. | *** ## Underlying Technology Memwyre runs on a high-performance stack optimized for semantic search and graph-based relationships: * **Vector Search Engine**: Stores and queries dense vector embeddings to perform fast semantic searches and locate conceptual themes in your documents. * **Knowledge Graph Database**: Maps deterministic relationships between entities, ensuring exact metadata profiles and constraints are matched and retrieved accurately. * **LLM Processing Workers**: Handles automated background pipelines for noise filtering, document cleaning, and semantic relationship extraction. * **Model Context Protocol (MCP)**: Leverages the open standard for direct, secure connections between your local IDEs and the remote memory vault. # Overview Source: https://docs.memwyre.tech/index Learn about Memwyre — the universal persistent memory layer that connects developer IDEs, browser tools, and autonomous AI agents through a unified entity graph. # Overview **Memwyre** is a universal memory layer for AI — a persistent, cross-tool knowledge vault that sits between you and the AI models you use daily. Instead of re-explaining your project architectures to Cursor, losing context when a Claude conversation ends, or copy-pasting developer guidelines into ChatGPT, Memwyre centralizes your context. It automatically stores, structures, and dynamically injects the relevant facts into whatever AI client you are active in. *** ## Core Pillars ### 1. Model Context Protocol (MCP) Memwyre operates as an MCP server. This allows AI clients like Claude Desktop, Cursor, and VS Code to natively query your memory vault. The AI client can autonomously search your memories or write new memories back to your vault during a conversation. ### 2. Hierarchical Entity Graphs Traditional RAG retrieves random text chunks based on keywords. Memwyre maps your knowledge into a graph structure. It knows that `Project A` uses `Database B` which has `Schema C`, ensuring that querying `Project A` brings in the entire context chain automatically. ### 3. Integrated Capturing Ecosystem * **Browser Extension**: Clip web pages, API docs, or save entire conversation histories from ChatGPT, Claude.ai, and Perplexity with one click. * **Ready-to-Use Connectors**: Connect Notion, GitHub, Google Drive, and Gmail to keep your memory vault continuously synchronized with your team's documents. * **Agent CLI Plugins**: Native terminal integrations for command-line agents like Claude Code and OpenClaw. *** ## Terminology | Concept | Description | | :----------------- | :-------------------------------------------------------------------------------------- | | **Memory** | A raw unit of ingested text — a note, clipped article, sync'd doc, or chat history. | | **Chunk** | A segmented slice of a larger Memory, vectorized for semantic retrieval. | | **Fact** | An extracted atomic truth (e.g., *Project X uses Vue 3*). Decays/updates over time. | | **Entity Profile** | A compiled metadata profile representing a unique project, repository, tool, or person. | | **MCP Server** | The standard interface exposing Memwyre search and writing tools to client IDEs. | *** ## Choose Your Integration Path Get started with the integrations that fit your workflow: * 🌐 **Web Browser & ChatGPT** — [Browser Extension Guide](/integrations/browser-extension) * 💻 **IDEs (Cursor, Claude Desktop, VS Code)** — [MCP Server Setup](/integrations/mcp-server) * 🤖 **Autonomous Agents (OpenClaw, Claude Code)** — [Agent Plugins Guide](/integrations/plugins/openclaw) *** ## Quick Start (60 Seconds) 1. **Create an Account**: Sign up at [memwyre.tech](https://memwyre.tech). 2. **Install the Browser Extension**: Download the extension ([guide](/integrations/browser-extension)). 3. **Configure the Token**: Go to your dashboard settings, copy your API token, and paste it into the extension. 4. **Begin Querying**: Open your IDE or ChatGPT — Memwyre is active and ready to feed context. # CLI Auto-Installer Guide Source: https://docs.memwyre.tech/integrations/cli-installer Step-by-step instructions for running the Memwyre CLI installer to configure local MCP servers and developer hooks. ## Quickstart Run the following command in your terminal to initialize Memwyre locally: ```bash theme={null} npx -y install-memwyre ``` This interactive CLI script automates the installation process, removing the need for manual configuration. *** ## Authentication & OAuth Callback Flow The installer handles the OAuth handshake securely using a local loopback handler: ```text theme={null} ┌──────────────┐ 1. Start Loopback ┌──────────────┐ │ Local CLI ├─────────────────────────────►│ Local Port │ │ Installer │ │ (Randomized) │ └──────┬───────┘ └──────┬───────┘ │ ▲ │ 2. Open Web Browser │ 4. HTTP POST ▼ │ Bearer Token ┌──────────────┐ 3. User logs in ┌──────┴───────┐ │ memwyre.tech │─────────────────────────────►│ Web App Auth │ │ /login │ │ Dashboard │ └──────────────┘ └──────────────┘ ``` 1. **Local Server Start**: The script starts a temporary, lightweight Express server on an ephemeral port (e.g. `http://localhost:50310`). 2. **Browser Redirection**: The script opens your default web browser and redirects you to the authentication page: `https://memwyre.tech/login?cli_port=50310` 3. **Authentication**: You sign in with Google, GitHub, or email. 4. **Token Delivery**: Once authenticated, the web application sends the secure Bearer Token to the local loopback address (`http://localhost:50310/callback`). 5. **Config Write**: The CLI captures the token, writes it to your global configurations (like `mcp.json` and `claude_desktop_config.json`), and shuts down the loopback listener. *** ## What the Installer Does The CLI script detects your installed developer applications and automatically maps the connection configurations for you using `mcp-remote` (a lightweight utility that tunnels MCP requests directly over HTTP to the Memwyre secure cloud server). For each application, it writes the following configuration: ### 1. Cursor * **Configuration Path**: `~/.cursor/mcp.json` * **JSON Structure**: ```json theme={null} "memwyre": { "command": "npx", "args": ["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer "] } ``` ### 2. VS Code (MCP Client) * **Configuration Path**: `%APPDATA%\Code\User\mcp.json` (Windows) or `~/Library/Application Support/Code/User/mcp.json` (macOS) * **JSON Structure**: ```json theme={null} "memwyre": { "type": "stdio", "command": "npx", "args": ["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer "] } ``` ### 3. Claude Desktop * **Configuration Path**: `%APPDATA%\Claude\claude_desktop_config.json` (Windows) or `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) * **JSON Structure**: ```json theme={null} "mcpServers": { "memwyre": { "command": "npx", "args": ["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer "] } } ``` ### 4. Codex * **Configuration Path**: `~/.codex/config.toml` * **TOML Structure**: ```toml theme={null} [mcp_servers.memwyre] enabled = true url = "https://server.memwyre.tech/mcp" http_headers = { Authorization = "Bearer " } ``` ### 5. Claude Code * **Action**: Executes the Claude CLI registration command directly in your shell: ```bash theme={null} claude mcp add memwyre -- npx -y mcp-remote https://server.memwyre.tech/mcp --header "Authorization:Bearer " ``` ### 6. Antigravity * **Configuration Path**: `~/.gemini/config/mcp_config.json` * **JSON Structure**: ```json theme={null} "memwyre": { "command": "npx", "args": ["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer "] } ``` *** ## Troubleshooting ### Port Conflict Error If the script fails to start the callback listener, you may see: ```text theme={null} Error: listen EADDRINUSE: address already in use 127.0.0.1:XXXX ``` * **Solution**: The script automatically attempts to find an open port, but firewall rules or VPN clients can block local loopback binds. Disable active VPNs or corporate proxy configurations during authentication. ### Token Expiration Warning If your IDE displays authentication errors: * Run the installer again (`npx -y install-memwyre`) to renew your token and update configuration files automatically. * Alternatively, generate an API key from your web dashboard and manually set it as `MEMWYRE_API_KEY` in your client's environment block. # Universal MCP Server Guide Source: https://docs.memwyre.tech/integrations/mcp-server Universal guide to connecting Memwyre to Model Context Protocol (MCP) clients like Claude Desktop, Cursor, and VS Code. ## Overview The [Model Context Protocol](https://modelcontextprotocol.io/) is an open standard that connects AI systems with external tools and data sources. By running the Memwyre MCP Server locally, you give your IDE or agent (Claude Desktop, Cursor, VS Code, etc.) direct access to your centralised memory — no more copy-pasting context manually. ## Prerequisites Before you begin, make sure you have: * **Python 3.10+** installed on your machine. * Your **`MEMWYRE_API_KEY`** — generate one from **Settings → API Keys** in the Memwyre web app. * The `mcp_server.py` script downloaded to a permanent location on your hard drive. ## Connection Protocols Memwyre supports two connection protocols for Model Context Protocol (MCP): 1. **Remote HTTP Tunneling (Recommended)**: Utilizes the `mcp-remote` utility to tunnel commands to our secure cloud endpoint (`https://server.memwyre.tech/mcp`). 2. **Local Python Execution**: Runs the `mcp_server.py` file locally on your machine using Python, executing local SQLite vector updates. *** ## Setup Configurations ### 1. Claude Desktop (Remote) Add this server block to your Claude configuration file: * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json` * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json` ```json theme={null} { "mcpServers": { "memwyre": { "command": "npx", "args": ["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer your_token_here"] } } } ``` ### 2. VS Code & Cursor (Remote) In your IDE settings panel, register the MCP server as: * **Command**: `npx` * **Args**: `["-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer your_token_here"]` ### 3. Local Python Script Setup If running fully self-hosted, download `mcp_server.py` and invoke it directly: ```json theme={null} { "mcpServers": { "memwyre-local": { "command": "python", "args": ["/absolute/path/to/mcp_server.py"], "env": { "MEMWYRE_API_KEY": "your_api_key_here" } } } } ``` *** ## Available Tools Once connected, your IDE or agent will have access to the following tools:
search\_memwyre (Primary Search) The most important tool for retrieving context. It performs a semantic search across your entire vault. * **Parameters:** * `query` (Required): Your search terms or question. * `purpose` (Optional): Hint for context formatting. Options: `general`, `code`, or `summary`.
save\_memory (Capture Context) Save new information or notes directly into your Memwyre Inbox. * **Parameters:** * `text` (Required): The content you want to save. * `tags` (Optional): A list of tags to categorize the memory (e.g. `["project-x", "todo"]`). * `source` (Optional): Origin of the memory (defaults to `mcp`).
approve\_memory (Approve Ingestion) Approve a pending memory in the Inbox and begin its ingestion process. * **Parameters:** * `memory_id` (Required): The ID of the memory, starting with `mem_` (e.g. `mem_123`).
discard\_memory (Discard from Inbox) Discard a pending memory from the Inbox. * **Parameters:** * `memory_id` (Required): The ID of the memory, starting with `mem_` (e.g. `mem_123`).
generate\_prompt (Prompt Engineering) Retrieves relevant context and wraps it in a pre-formatted prompt for an LLM. * **Parameters:** * `query` (Required): The topic to generate a prompt for. * `template` (Optional): The prompt structure. Options: `standard`, `code`, or `summary`.
get\_document (Full Text Retrieval) Retrieve the entire content of a specific document (PDF, Doc, or Web Page) by its ID. * **Parameters:** * `doc_id` (Required): The numeric ID of the document (e.g. `123`).
list\_memories (Discovery) List the most recent memories and documents added to your vault. * **Parameters:** * `limit` (Optional): Number of items to return (default: 10). * `offset` (Optional): Pagination offset.
get\_inbox (Pending Review) Lists all memories currently in your "Inbox" status that are awaiting review or confirmation.
update\_memory (Edit) Update the content of an existing memory snippet. * **Parameters:** * `memory_id` (Required): The ID of the memory, starting with `mem_` (e.g. `mem_45`). * `content` (Required): The new text content.
delete\_memory (Cleanup) Permanently remove a memory or document from your vault. * **Parameters:** * `memory_id` (Required): The ID of the item, starting with `mem_` or `doc_` (e.g. `doc_12`).
search\_by\_date (Chronological Search) Find memories created within a specific timeframe. * **Parameters:** * `start_date` (Required): Start date in `YYYY-MM-DD` format. * `end_date` (Optional): End date in `YYYY-MM-DD` format.
get\_all\_tags (Taxonomy) Retrieve a comprehensive list of all tags currently used across your entire memory vault.
*** ## Troubleshooting **Claude Desktop doesn't show the Memwyre tools.**
Check that the `command` path resolves correctly — try `python3` instead of `python` on macOS/Linux if deploying local scripts, or confirm your `npx` command executes correctly in your shell. **`MEMWYRE_API_KEY` environment variable not found.**
For local server python deployments, ensure the key is set inside the `env` block of your config file, not as a system environment variable. For remote instances, ensure your Bearer token in the header argument is valid. # Claude Desktop MCP Integration Source: https://docs.memwyre.tech/integrations/mcp-server/claude Configure Memwyre as a local MCP server for Claude Desktop to maintain a persistent chat memory layer. ## Configuration File Locations Add the Memwyre server configuration to your `claude_desktop_config.json` file. Depending on your operating system, this file is located at: * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json` * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json` ## Setup Options ### Option A: Cloud Remote Tunnel (Recommended) This uses our hosted `mcp-remote` tunnel to execute commands securely against the Memwyre Cloud API. 1. Open your configuration file and add the `memwyre` server block: ```json theme={null} { "mcpServers": { "memwyre": { "command": "npx", "args": [ "-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer your_api_key_here" ] } } } ``` 2. Replace `your_api_key_here` with the token generated from **Settings → API Keys** in the Memwyre web app. ### Option B: Local Python Instance For fully self-hosted environments: 1. Download the `mcp_server.py` script. 2. Register the python script inside your configuration file: ```json theme={null} { "mcpServers": { "memwyre-local": { "command": "python", "args": ["/absolute/path/to/mcp_server.py"], "env": { "MEMWYRE_API_KEY": "your_api_key_here" } } } } ``` ## Verifying Connection 1. Close and completely restart your **Claude Desktop** application. 2. Once restarted, click on the **plug icon** at the bottom-right corner of the chat input box. 3. You should see `memwyre` listed as an active source, exposing tools like `search_memwyre` and `save_memory`. *** ## Detailed Parameter Reference When configuring the `memwyre` server block in your JSON settings, the following parameters are parsed by the Claude Desktop application when spawning the MCP subprocess: * **`command`**: The primary executable to launch. When using `npx`, Claude Desktop uses your local Node.js environment path to resolve the command. * **`args`**: The array of CLI parameters passed directly to the command: * `-y`: Forces npm to run non-interactively and auto-install the `mcp-remote` client without prompting. * `mcp-remote`: The official Memwyre Client library for remote secure tunnel gateway connections. * `https://server.memwyre.tech/mcp`: The endpoint URL of the Memwyre Cloud MCP engine. * `--header`: Configures custom HTTP authorization headers. * `Authorization:Bearer your_api_key_here`: Passes your private authentication key securely. * **`env`** (Optional for Option A, required for Option B): Specific environment variables supplied to the spawned subprocess. *** ## Technical Details: Exposed Tools & Parameters Once the connection is established, Claude Desktop automatically queries the MCP server's schemas. Memwyre exposes the following tools directly into Claude's prompt execution scope: 1. **`search_memwyre`**: * **Description**: Queries the Memwyre Vault for matching semantic memories, context rules, and style guides. * **Arguments**: `query` (string, the semantic search string), `limit` (integer, maximum matching nodes to return). * **Usage**: Triggered when you ask Claude questions about past projects, configurations, or personal notes. 2. **`save_memory`**: * **Description**: Ingests new text segments, project constraints, or architectural updates into your memory graph. * **Arguments**: `content` (string, the raw text content to memorize), `tags` (array of strings, category tags for organization). * **Usage**: Triggered when you instruct Claude: "Remember that we changed our database port to 5432" or "Save this setup configuration". *** ## Troubleshooting & Debugging If the Memwyre connection does not initialize, check the following common issues: ### 1. Inspecting Claude Desktop MCP Logs Claude Desktop writes all subprocess stdout/stderr and JSON-RPC connection failures to a local log file. Check these paths for error details: * **macOS**: `~/Library/Logs/Claude/mcp.log` * **Windows**: `%APPDATA%\Claude\logs\mcp.log` Common errors like `npx: command not found` indicate that the Node.js path is not accessible by the Claude Desktop GUI app environment. In this case, ensure Node.js is installed globally and added to your system path. ### 2. Testing NPX Manually Before launching Claude, verify the remote client runs successfully in your local shell by running: ```bash theme={null} npx -y mcp-remote https://server.memwyre.tech/mcp --header "Authorization:Bearer YOUR_KEY" ``` If this succeeds, the console will print `Listening on stdio...` and wait for JSON-RPC messages. You can exit using `Ctrl+C`. # Cursor AI IDE MCP Integration Source: https://docs.memwyre.tech/integrations/mcp-server/cursor Configure Memwyre inside Cursor AI IDE to maintain persistent codebase memories across editing sessions. ## Setup Steps 1. Open **Cursor Settings** (gear icon in the top right, or `Ctrl + Shift + J` / `Cmd + Shift + J`). 2. Go to **Features** and scroll down to the **MCP** section. 3. Click **+ Add New MCP Server**. 4. Enter the details for the server configuration: * **Name**: `Memwyre` * **Type**: `command` * **Command / Args**: ```bash theme={null} npx -y mcp-remote https://server.memwyre.tech/mcp --header "Authorization:Bearer your_api_key_here" ``` 5. Replace `your_api_key_here` with your Memwyre API Key. 6. Click **Save**. ## Using Memwyre in Cursor Once registered, Cursor automatically detects the available tools. * Type `@Memwyre` or ask Cursor's chat assistant: *"Search my memory for X"* * The assistant will execute `search_memwyre` and pull the matching memories into your prompt context. *** ## Detailed Configuration Options When setting up the MCP server in the Cursor settings UI, you are prompted to configure three key fields: 1. **Name**: A unique identifier for the server inside Cursor's registry (we recommend `Memwyre` or `memwyre-mcp`). 2. **Type**: Select `command`. This tells Cursor to spawn a local subprocess. Under the hood, Cursor launches this command using your operating system's default shell environment, mapping the standard input and standard output streams directly to the JSON-RPC interface. 3. **Command / Args**: The command line string. It uses `npx` to auto-fetch the latest `mcp-remote` client package and connect to our secure websocket API gateway at `https://server.memwyre.tech/mcp`. *** ## Best Practices: Codebase Context & Project Profiles Using Memwyre inside Cursor provides a powerful, persistent context layer that survives when you close your IDE or switch branches. Here is how to optimize the integration: * **Semantic Scope Matching**: When you ask a question in Cursor Chat or Composer, the LLM parses the current query. If it detects references to environment setup, styling rules, or API paths, it automatically invokes the `search_memwyre` tool. It retrieves relevant conventions from your vault and injects them as system prompts. * **Project-Specific Memories**: To organize your memories, use custom tags when adding guidelines via the Web Dashboard (e.g. `[react, tailwind, typescript]`). When Cursor queries the vault, the matching engine uses these tags to retrieve only the rules appropriate for the files currently open in your workspace. * **Workspace Profiles**: Maintain distinct profiles for personal projects vs corporate codebases by configuring separate API tokens for different workspaces. *** ## Troubleshooting Cursor Connection Issues If the Memwyre server fails to show a green status dot or is stuck in an error loop: ### 1. Stuck on "Connecting" * **Cause**: This usually means Cursor is unable to resolve the `npx` executable in its environment path. * **Fix**: Verify that Node.js is installed globally on your machine. Open a terminal and run `node -v` and `npx -v`. If they are not found, install the Node.js package. On Windows, make sure to restart Cursor after modifying your system environment variables. ### 2. Status Dot is Red ("Error") * **Cause**: Typically indicates an invalid or expired API authorization token, or a network firewall blocking outbound WebSocket traffic. * **Fix**: Double check that the token copy-pasted into the `--header "Authorization:Bearer YOUR_KEY"` string matches exactly and has no trailing spaces. You can generate a fresh token by going to the Memwyre web dashboard and navigating to **Settings → API Keys**. ### 3. Force Reloading the MCP Server If you update your configuration parameters, Cursor may not reload the process automatically. Click the **Refresh / Reload** icon next to the Memwyre entry in Cursor Settings > Features > MCP to restart the subprocess. # VS Code MCP Agent Caching Source: https://docs.memwyre.tech/integrations/mcp-server/vscode ## Setup via Cline / Roo-Code 1. Install the **Cline** or **Roo-Code** extension from the VS Code Marketplace. 2. Open the extension panel in the sidebar. 3. Click the **Settings (gear icon)** at the top right of the extension panel. 4. Scroll down to the **MCP Mode** section and enable it. 5. Edit your extension's MCP configuration settings: * **Cline**: click **Edit MCP Config** (opens `cline_mcp_settings.json`). * Add the following block: ```json theme={null} { "mcpServers": { "memwyre": { "command": "npx", "args": [ "-y", "mcp-remote", "https://server.memwyre.tech/mcp", "--header", "Authorization:Bearer your_api_key_here" ] } } } ``` 6. Save the configuration file. Cline/Roo-Code will automatically start the server. ## Verification In the extension's MCP dashboard tab, you will see `memwyre` listed as connected with 10+ active tools. The agent is now ready to query your database for contextual code references! *** ## Configuration Settings File Paths Depending on the extension you are using, the configuration settings are stored in your VS Code user application data folders. You can edit them directly in the IDE or open the files at these physical locations: * **Cline Settings Path**: * **macOS**: `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` * **Windows**: `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json` * **Linux**: `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` * **Roo-Code Settings Path**: * Replace `saoudrizwan.claude-dev` in the paths above with the Roo-Code storage directory `roodev.roo-cline`. *** ## Agent Integration: Cline & Roo-Code Workflows Autonomous coding agents (like Cline and Roo-Code) operate by recursively executing tasks in a loop: reading files, running terminal commands, and editing code. Integrating Memwyre into these workflows provides key benefits: * **Long-Term Debugging History**: If Cline encounters a compiler error, it queries the memory vault using `search_memwyre` to see if a similar error was solved in a past session. This saves significant developer time by preventing the agent from repeating the same debugging loops. * **Architectural Guardrails**: You can store your project's architectural guidelines (such as styling conventions, design patterns, or test coverages) directly in your Memwyre Vault. The agent queries these rules on startup and applies them automatically during file edits. * **Token Optimization**: Since the agent retrieves context dynamically through the MCP tool, it does not need to read the entire workspace into its system prompt, keeping token usage low and preventing context window exhaustion. *** ## Troubleshooting VS Code Connection Errors If the Memwyre server fails to show a healthy connection in the extension settings tab: ### 1. NPX Client Install Failures If you see installation error logs in the extension output console, it usually means the extension is unable to find the global Node/npx installation. * **Fix**: Verify that Node.js is accessible in your environment path by opening the VS Code integrated terminal and running `npx -v`. If it is not found, install Node.js and restart VS Code. ### 2. Authorization Token Issues Ensure the API authorization key has been copied correctly. You can test your key by making a curl request in your terminal: ```bash theme={null} curl -H "Authorization: Bearer YOUR_KEY" https://server.memwyre.tech/api/v1/health ``` If this health check succeeds, the token is valid and the issue lies in your JSON formatting. ### 3. Restarting the Server Process If the connection is lost or settings change, you can force-restart the subprocess: * Open the Cline/Roo-Code panel. * Click the **MCP** tab at the bottom of the panel. * Locate the `memwyre` entry and click the **Restart / Refresh** icon. # Claude Code Source: https://docs.memwyre.tech/integrations/plugins/claude Integrate Memwyre lifecycle hooks into Claude Code CLI to automatically save and retrieve terminal session memory. ## Overview Claude Code is a command-line tool that allows you to interact with Claude directly in your terminal. By default, Claude Code has no long-term memory of past tasks. The Memwyre Claude Plugin bridges this gap: 1. **Context Injection (`SessionStart`)**: When you launch Claude Code, the plugin automatically retrieves relevant past memories matching your current project folder and injects them as start context. 2. **Session Archival (`Stop` / `SessionEnd`)**: When you exit Claude Code, the plugin parses your session transcript and automatically uploads it to Memwyre, saving new insights and code updates for future sessions. ## Installation ### 1. Install the Package Install the Memwyre Claude Plugin globally: ```bash theme={null} npm install -g @memwyre/claude-memwyre ``` ### 2. Register Plugin Hooks in Claude Code Register the plugin by editing your Claude Code configuration directory (typically located at `~/.claude/`): Open `~/.claude/hooks.json` (create it if it doesn't exist) and add the hooks block pointing to the installed script: ```json theme={null} { "description": "Memwyre: Persistent autonomous memory", "hooks": { "SessionStart": [ { "hooks": [ { "type": "command", "command": "node \"/path/to/global/node_modules/@memwyre/claude-memwyre/dist/inject-memory.cjs\"", "timeout": 30 } ] } ], "Stop": [ { "hooks": [ { "type": "command", "command": "node \"/path/to/global/node_modules/@memwyre/claude-memwyre/dist/capture-session.cjs\"", "timeout": 30 } ] } ] } } ``` ## Configuration Ensure the following environment variables are set in your shell session before launching Claude Code: ```bash theme={null} export MEMWYRE_API_KEY="your_api_key_here" export MEMWYRE_API_URL="https://server.memwyre.tech" # Use http://127.0.0.1:8000 for local self-hosting ``` # Grok Build & Grok Bot Source: https://docs.memwyre.tech/integrations/plugins/grok Give Grok Bot persistent, cross-bot shared memory. Automatically sync context and share knowledge across your entire Grok agent roster. ## Overview Grok Bot allows you to run a roster of specialized agents (e.g., Researcher, Coder, Ops). While they can hand off tasks, they **do not natively share memory**. If your Researcher bot figures something out, your Coder bot starts with a blank slate. The Memwyre Grok Plugin solves this by providing a **shared memory brain** for your entire agent roster: 1. **Cross-Bot Shared Memory**: When one bot finishes a session, its transcript is captured via the `Stop` hook and extracted into project memories. When the next bot starts, the `SessionStart` hook injects those memories. **Bot B instantly knows what Bot A learned.** 2. **True Portability**: Your memory vault is agent-agnostic. Memories captured in Claude Code or OpenClaw are instantly available to Grok Bot, and vice versa. 3. **Curation & Control**: Unlike native auto-memory, Memwyre puts captured insights into an Inbox for you to approve or discard. ## Installation The plugin uses pure Node.js built-ins for its hooks, meaning **zero npm dependencies** and no installation bloat. ### Option A: Standard CLI Install ```bash theme={null} grok plugin install @memwyre/grok-plugin ``` ### Option B: Manual Installation Copy the plugin files into your user or project Grok configuration directory: ```bash theme={null} # For all Grok sessions on your machine mkdir -p ~/.grok/plugins/memwyre cp -r path/to/grok-plugin/plugin/* ~/.grok/plugins/memwyre/ ``` > **Note:** If installing to a project-level `.grok` directory, you must run `/hooks-trust` in Grok Build before the hooks will execute. ## Configuration Set your Memwyre API key in your shell environment (e.g., in your `~/.bashrc` or `~/.zshrc`) before launching `grok`: ```bash theme={null} export MEMWYRE_API_KEY="bv_sk_your_api_key_here" export MEMWYRE_API_URL="https://server.memwyre.tech" # Optional: For self-hosted vaults ``` > Generate your API key from **Settings → API Keys** in the Memwyre web app. ## How the Hooks Work The plugin registers two deterministic shell hooks in `hooks.json`: * **`SessionStart`**: Fires when a Grok session begins. It reads the current workspace directory, fetches relevant memories from Memwyre, and injects them into the `additionalContext` of the system prompt. * **`Stop`**: Fires when the session ends or the agent pauses. It safely reads the `.jsonl` transcript of the conversation and posts it to the Memwyre extraction backend. Both hooks are strictly non-blocking (always exit `0`) and will silently fail open if the API is unreachable, ensuring your Grok workflow is never interrupted. # Openclaw Source: https://docs.memwyre.tech/integrations/plugins/openclaw Install the Memwyre plugin for OpenClaw autonomous agents to query and persist memory graphs across agent runs. ## Overview OpenClaw agents operate within a single session and lose context when that session ends. This plugin bridges the gap — giving your agent access to Memwyre's vault so it can recall previous sessions, look up project documentation, and save its own findings for future runs. ## Available Tools Once configured, the OpenClaw agent can use the following Memwyre tools: | Tool | Description | | ---------------- | -------------------------------------------------- | | `save_memory` | Save a new memory or note into your Memwyre Inbox. | | `search_memwyre` | Run a semantic search across your Memwyre Vault. | ## Installation The plugin (Version **2.0.14**) can be installed globally or linked locally for custom development runs: ### Option A: Standard CLI Install ```bash theme={null} openclaw plugins install @memwyre/openclaw-plugin@2.0.14 ``` ### Option B: Local Linking (Development) If modifying the plugin source, link the package manually: 1. Navigate to the plugin folder: ```bash theme={null} cd openclaw-plugin npm install ``` 2. Link the package to your local OpenClaw workspace: ```bash theme={null} openclaw plugins install . ``` ## Configuration Add the following to your OpenClaw settings file (typically `~/.openclaw/config.json`): ```json theme={null} "plugins": { "entries": { "openclaw-plugin": { "enabled": true, "config": { "apiKey": "bv_sk_your_api_key_here", "hostUrl": "https://server.memwyre.tech" } } } } ``` > Generate your API key from **Settings → API Keys** in the Memwyre web app. ## Important: Agent Tool Profile To ensure the Memwyre tools are injected into your agent session, **set your agent tool profile to `full` or `coding`**. If your profile is set to `standard` or `minimal`, OpenClaw may disable custom memory plugins to reduce token usage. # OpenCode Source: https://docs.memwyre.tech/integrations/plugins/opencode Install the Memwyre plugin for OpenCode to inject shared coding patterns, architecture decisions, and conventions directly into code generation. ## Overview OpenCode generates excellent code, but keeping it aligned with your team's specific architecture decisions and styling conventions can be challenging. The Memwyre OpenCode plugin bridges this gap by automatically injecting shared coding patterns directly into OpenCode's context window. By connecting OpenCode to your Memwyre Vault, the extension can query your established patterns (like error handling protocols, component structures, or API layer standards) to keep all generated code aligned with your architecture. ## Available Tools Once configured, OpenCode will have access to the following Memwyre tools: | Tool | Description | | ---------------- | --------------------------------------------------------------------------- | | get\_conventions | Retrieve the active coding conventions for the current project. | | search\_memwyre | Run a semantic search across your Memwyre Vault for architecture decisions. | ## Installation The plugin (Version **1.1.5**) can be installed directly through the OpenCode extension marketplace or via CLI. ### Option A: Extension Marketplace 1. Open your IDE's Extensions view. 2. Search for **Memwyre for OpenCode**. 3. Click **Install**. ### Option B: CLI Install `ash opencode ext install memwyre-opencode-plugin ` ## Configuration After installation, configure the plugin to connect to your Memwyre account: 1. Open the OpenCode command palette (Ctrl+Shift+P or Cmd+Shift+P). 2. Run Memwyre: Configure API Key. 3. Enter your Memwyre API key. 4. (Optional) Run Memwyre: Set Host URL if you are using a self-hosted instance. > Generate your API key from **Settings -> API Keys** in the Memwyre web app. ## Best Practices To get the most out of the OpenCode integration: * **Tag your conventions**: When saving architecture decisions to Memwyre, use the tag #opencode or #convention so the plugin can easily retrieve them. * **Project-Specific Context**: Ensure your OpenCode workspace is mapped to the correct Memwyre Project Name to prevent cross-contamination of conventions between different codebases. # RAG vs. Persistent AI Memory Source: https://docs.memwyre.tech/rag-vs-memory Compare traditional RAG retrieval with Memwyre's persistent memory layer to see how entity profiling improves context relevance. ## Key Differences Traditional RAG setups are stateless file-retrieval systems. Memwyre functions as a state-aware, dynamic memory layer. | Feature | Traditional RAG | Memwyre Memory Layer | | :------------------------ | :----------------------------------------------------------------------------- | :-------------------------------------------------------------------------- | | **Data Representation** | Static, isolated chunks of files or web pages stored in a vector index. | An interconnected knowledge graph of entities and active relationships. | | **Context Matching** | Relies entirely on fuzzy semantic similarity, often missing exact constraints. | Combines fuzzy semantic matching with deterministic entity-fact lookup. | | **State Resolution** | Stale and contradicting data coexist in search results, confusing the LLM. | Automatically flags superseded notes, serving only the latest active state. | | **Query Lifecycle** | Stateless. Each prompt triggers an isolated similarity search. | State-aware. Memories decay, boost, and form connections over time. | | **IDE/Agent Integration** | Static index configurations or manual copy-pasting of context. | Real-time native integration via Model Context Protocol (MCP). | *** ## Advantages of a Memory Layer Using a stateful memory layer like Memwyre offers major benefits over standard vector RAG: * **Self-Correcting State**: When codebase configurations or guidelines change, new captures automatically supersede old ones. This prevents your AI from getting confused by stale endpoints, retired libraries, or outdated setup steps. * **Compact Context Footprint**: Standard RAG often dumps large, noisy file sections into LLM prompts, leading to higher API costs and latency. Memwyre retrieves only relevant, high-precision facts and semantic snippets (averaging **3,000 tokens**), keeping prompt windows clean and fast. * **Multi-Hop Reasoning**: Because facts are structured in a relational graph, Memwyre can resolve indirect associations. For instance, if you ask about a project's database settings, the system can traverse linked relationships (e.g. `[Project] -> [uses] -> [Service]` and `[Service] -> [configured with] -> [Port]`) to assemble the correct context. * **Continuous, Zero-Reindex Ingestion**: Traditional RAG requires rebuilding or updating heavy database indexes when data changes. Memwyre incrementally appends new memories and facts to the graph dynamically, making updates instantly searchable. * **Zero Context Duplication**: Standard RAG often retrieves multiple chunks containing redundant information. Memwyre merges facts and deduplicates semantic data before feeding it to the AI. *** ## How It Works in Practice ### 1. Static Search vs. Connected Graph Traditional RAG slices text into blocks (chunks) and indexes them. When you query, it performs a mathematical similarity check to retrieve the closest matching text blocks. If your codebase changes or a requirement is updated in another file, standard RAG cannot connect the dots; it simply retrieves both chunks, forcing the LLM to figure out which instructions are valid. Memwyre parses your incoming notes and maps them as a living graph. It tracks which rules supersede others, maintaining a clean state record. ### 2. Fuzzy Matching vs. Deterministic Retrieval If you ask a traditional RAG tool: *"what are the database credentials for Project Y?"*, it will search for words semantically similar to your query. If it finds similar words in another project's notes, it may return incorrect credentials. Memwyre identifies the specific entity (e.g. `Project Y`) and deterministically retrieves the active facts linked to that entity. This ensures high-precision retrieval for critical parameters. ### 3. Real-Time IDE Context Sync Standard RAG systems are typically built for chatbots, search portals, or static document Q\&A. They are difficult to integrate directly into active developer environments. As a universal memory layer, Memwyre exposes standard Model Context Protocol (MCP) endpoints. Development clients (like Cursor or VS Code) can query your memory vault in the background during active coding sessions, injecting codebase decisions and conventions with zero friction. # Security & Data Privacy Source: https://docs.memwyre.tech/security Read about Memwyre security practices, including private memory vaults, data encryption, and local offline deployment. ## 1. The Zero-Knowledge Standard Our primary mandate is that **your data belongs to you**. In cloud-connected setups, Memwyre uses a Zero-Knowledge design for prompt evaluation and context retrieval: * **No Query Logging**: Your search queries, generated prompts, and context payloads are evaluated in-memory and never logged to permanent disk storage on our servers. * **On-the-Fly Processing**: Documents and code snippets sent for vectorization are processed immediately and saved to your isolated database instance. Raw file contents are not archived in flat files or accessible by third parties. * **Local Processing Options**: When running self-hosted, 100% of the ingestion, vectorization, and inference is kept within your local network. No external API calls are made. *** ## 2. Data Encryption Memwyre enforces industry-standard encryption protocols at every lifecycle stage of your data: ### Token Authorization & Session Expiration * Client connections are authenticated using JSON Web Tokens (JWT) signed via the `HS256` algorithm. * **Access Tokens**: Expire after **15 minutes** to minimize leakage vectors. * **Refresh Tokens**: Expire after **30 days** before requiring a new login challenge. * **Rate Limits**: Free tier accounts are capped at a token quota threshold of **100,000 tokens daily** (`MAX_DAILY_TOKENS`), backed by Redis-based token buckets. * **Bot Defenses**: External entry points (like signup/login pages) validate requests against Cloudflare Turnstile CAPTCHA checks. ### In Transit * All API connections between client platforms (the Chrome Extension, CLI, MCP Server, and IDEs) and the Memwyre server require HTTPS. * We enforce **TLS 1.3** (with TLS 1.2 fallback) for all network endpoints, protecting your data against interception or man-in-the-middle attacks. ### At Rest * Vector embeddings and metadata indices stored in our cloud databases are encrypted using **AES-256**. * API tokens and service integration credentials (e.g., Notion, GitHub secrets) are double-encrypted using a salted key-derivation function before storage. *** ## 3. Workspace Sandboxing When you connect local IDEs (like Cursor or VS Code) to your Memwyre MCP Server, your model gains high-speed search capabilities. To prevent cross-project context leakages: * **Workspace Boundaries**: The MCP server restricts search scopes to the active project folder. An AI agent working on a personal project cannot retrieve context from a work codebase unless explicitly configured. * **Path Filtering**: You can declare paths or pattern exclusions (similar to `.gitignore` files) inside your workspace configurations to prevent the indexing of sensitive directories (like `.env`, `.git`, or `node_modules`). * **Process Isolation**: The local MCP process runs under standard user-level permissions. It cannot scan systemic network directories or read from disks outside of your workspace folder without permission. *** ## 4. Third-Party AI Integrations When using Memwyre to inject context into chat interfaces (e.g. ChatGPT, Claude.ai, or Gemini): * The browser extension injects retrieved context directly into the browser's DOM textarea before submission. * The data is processed by the AI vendor (OpenAI, Anthropic, Google) under their standard enterprise privacy policies. Memwyre does not store or intercept the final LLM response. * For maximum security, we recommend opting out of data training within your respective OpenAI, Anthropic, or Google account settings. # Self-Hosting Source: https://docs.memwyre.tech/self-hosting Learn how to host Memwyre locally or on your own private cloud using Docker Compose, PostgreSQL, and pgvector. ## Architecture Overview A self-hosted Memwyre deployment consists of four primary components: 1. **Backend API (`memwyre-backend`)**: The core FastAPI/Python service handling ingestion, search pipelines, and client requests. 2. **Celery Worker (`celery-worker`)**: Resolves background tasks such as parsing web documents, downloading YouTube transcripts, and rebuilding relationship edges. 3. **Database (`postgres` with `pgvector`)**: Stores relational structured data and high-dimensional semantic vector embeddings. 4. **Cache & Queue (`redis`)**: Serves as the message broker for Celery and caching layer for rapid API queries. ```text theme={null} ┌──────────────────────┐ │ Client / IDE │ └──────────┬───────────┘ │ ▼ ┌──────────────────────┐ │ memwyre-backend │ └─────┬──────────┬─────┘ │ │ ▼ ▼ ┌──────────┐ ┌──────────┐ │ postgres │ │ redis │ └──────────┘ └────┬─────┘ │ ▼ ┌──────────────────────┐ │ celery-worker │ └──────────────────────┘ ``` *** ## Docker Compose Quickstart Create a `docker-compose.yml` file in your installation directory: ```yaml theme={null} version: '3.8' services: db: image: pgvector/pgvector:pg16 container_name: memwyre-db environment: POSTGRES_DB: memwyre POSTGRES_USER: memwyre_user POSTGRES_PASSWORD: super_secure_db_password ports: - "5432:5432" volumes: - pgdata:/var/lib/postgresql/data restart: unless-stopped healthcheck: test: ["CMD-SHELL", "pg_isready -U memwyre_user -d memwyre"] interval: 5s timeout: 5s retries: 5 redis: image: redis:7-alpine container_name: memwyre-redis ports: - "6379:6379" volumes: - redisdata:/data restart: unless-stopped healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 5s timeout: 5s retries: 5 backend: image: ramblinghermit0403/memwyre-backend:latest container_name: memwyre-backend environment: - DATABASE_URL=postgresql://memwyre_user:super_secure_db_password@db:5432/memwyre - REDIS_URL=redis://redis:6379/0 - SECRET_KEY=generate_a_random_jwt_secret_here - EMBEDDING_MODEL=nomic-embed-text - OLLAMA_HOST=http://host.docker.internal:11434 - LLM_PROVIDER=ollama - LLM_MODEL=llama3 ports: - "8000:8000" depends_on: db: condition: service_healthy redis: condition: service_healthy extra_hosts: - "host.docker.internal:host-gateway" restart: unless-stopped worker: image: ramblinghermit0403/memwyre-backend:latest container_name: memwyre-worker command: celery -A app.worker worker --loglevel=info environment: - DATABASE_URL=postgresql://memwyre_user:super_secure_db_password@db:5432/memwyre - REDIS_URL=redis://redis:6379/0 - EMBEDDING_MODEL=nomic-embed-text - OLLAMA_HOST=http://host.docker.internal:11434 - LLM_PROVIDER=ollama - LLM_MODEL=llama3 depends_on: db: condition: service_healthy redis: condition: service_healthy extra_hosts: - "host.docker.internal:host-gateway" restart: unless-stopped volumes: pgdata: redisdata: ``` *** ## Environment Variables Configure these variables inside your `.env` file or docker-compose block: | Variable | Description | Default / Example | | ----------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | | `DATABASE_URL` | SQLAlchemy-compatible connection string. If omitted, Memwyre defaults to local SQLite. | `postgresql://user:pass@db:5432/db` or `sqlite:///brain_vault.db` | | `REDIS_URL` | Redis URL used for celery message passing and query cache. | `redis://redis:6379/0` | | `SECRET_KEY` | Hex token used to sign authentication JWT keys. | `3a5d8f...` (Use `openssl rand -hex 32`) | | `DEV_MODE` | If set to `True`, subscription checks are bypassed (unlimited usage gating). | `False` | | `FREE_MEMORY_LIMIT` | Maximum memories allowed for a free user account. | `50` | | `FREE_DOCUMENT_LIMIT` | Maximum documents allowed for a free user account. | `10` | | `FREE_CHAT_LIMIT` | Maximum chats allowed for a free user account. | `30` | | `MAX_CHARS_PER_MEMORY` | Character limit threshold for a single memory unit. | `25000` | | `TURNSTILE_SECRET_KEY` | Cloudflare Turnstile token used for bot challenge validations. | `0x4AAAAAA...` | | `DODO_PAYMENTS_API_KEY` | API authorization token for Dodo Payments gateway. | `dp_live_...` | | `LLM_PROVIDER` | Language model platform. Options: `ollama`, `openai`, `anthropic`. | `ollama` | | `LLM_MODEL` | Main inference model for relationship parsing and summarization. | `llama3` or `gpt-4o-mini` | | `EMBEDDING_MODEL` | Model used to generate vector dimensions for retrieval. | `nomic-embed-text` | | `OLLAMA_HOST` | Host URL pointing to your local Ollama runtime. | `http://host.docker.internal:11434` | *** ## Local LLM Setup (Ollama) To run a zero-cloud setup, route all embedding and extraction tasks to [Ollama](https://ollama.com). ### Step 1: Install & Launch Ollama Install Ollama on your host system (macOS, Windows, or Linux). Ensure Ollama runs locally by verifying: ```bash theme={null} curl http://localhost:11434/api/tags ``` ### Step 2: Download Required Models Memwyre requires a dense vector embedding model and an inference model. Pull them using the CLI: ```bash theme={null} # Pull the semantic embedding model (768 dimensions) ollama pull nomic-embed-text # Pull the inference model for memory graph extraction ollama pull llama3 ``` ### Step 3: Run Docker Containers Ensure `extra_hosts` is mapped to `host.docker.internal:host-gateway` in your `docker-compose.yml` so that Docker containers can contact your host's Ollama port (`11434`). Spin up your cluster: ```bash theme={null} docker-compose up -d ``` ### Step 4: Verify Local Connection Inspect logs to verify that Memwyre connects to Ollama successfully during startup: ```bash theme={null} docker logs memwyre-backend ``` If you see vector dimension initialisation messages pointing to `nomic-embed-text`, your offline memory vault is up and running! 🚀 # Use Cases Source: https://docs.memwyre.tech/use-cases Explore core use cases for Memwyre, including codebase synchronization, personalized AI memory, and team workflows. ## 1. Coding & IDE Context Sync * **The Workflow**: Synchronizing codebase architectures, framework versions, styling conventions, API keys, and architectural decisions with your local IDE (e.g. Cursor, VS Code, or Claude Desktop). * **Why Memwyre Helps**: Instead of manually uploading context files or copy-pasting setup steps, Memwyre's MCP server streams the exact codebase details to the LLM in the background. As configuration keys or dependencies update, the memory layer updates itself, preventing the AI from referencing outdated APIs. *** ## 2. Research & Knowledge Caching * **The Workflow**: Saving documentations, research papers, web articles, or technical guides during deep research sessions. * **Why Memwyre Helps**: Using the Browser Extension, you can capture full pages, selected paragraphs, or articles. Memwyre cleans page noise and index them semantically. When you draft articles or code implementation plans, you can query your vault directly for relevant insights. *** ## 3. Persistent Memory for Autonomous Agents * **The Workflow**: Equipping autonomous software agents (e.g. OpenClaw sessions or command-line scripts) with long-term memory across runs. * **Why Memwyre Helps**: Standard agents are stateless and start from zero on every execution, losing task progress or previous decisions. By interfacing via our API or plugin connectors, agents read and write task checkpoints to a persistent graph, enabling continual learning. *** ## 4. Media & Transcripts Digest * **The Workflow**: Ingesting meeting transcripts, audio files, or YouTube video records to query specific topics or discussions. * **Why Memwyre Helps**: You can feed video links or raw audio transcripts directly to Memwyre. The background worker parses the transcripts, extracts key facts, and embeds them. You can then prompt: *"what did we decide about the hosting server during the meeting?"* and get precise facts. *** ## 5. Unified Knowledge Connectors * **The Workflow**: Searching across scattered repositories like Google Drive, Notion workspaces, and local folders in a single query. * **Why Memwyre Helps**: Our workspace connectors automatically sync pages and files into your vault. Memwyre creates unified entity profiles across these tools, resolving relationships dynamically so your queries aggregate all relevant sources seamlessly.