Coding Tools

Use the same MemoryRouter vault across supported coding clients. This is a compatibility guide, not a claim that every editor feature or release has a native MemoryRouter plugin.

For deterministic lifecycle integrations, start with Claude Code or Codex. For explicit model-directed memory tools, use MCP. Proxy configuration only affects requests actually sent to the configured endpoint.

Prerequisites

• A MemoryRouter account and access to the intended vault.
• For proxy mode, provider credentials saved in MemoryRouter settings and a model available to that account.
• Permission to change your client's model connection. Enterprise clients may require an administrator.
• A separate test vault for initial verification. Never commit a real key in configuration examples.

Authentication and modes

For the OpenAI-compatible examples below:

The Memory Key authorizes the vault; MemoryRouter uses your stored provider credentials for inference. If you instead pass a provider API key, you must also send the supported X-Memory-Key header as described in the API reference. Exporting MEMORY_KEY alone does nothing in a client that never reads or transmits it.

Use :read for retrieval without capturing coding traffic. Use an unsuffixed writable key only when you intend routed requests to be stored. MCP connections use OAuth scopes, not these key suffixes. Read-only mode does not create new memories for the proof below.

Cursor

Cursor is a coding editor with its own hosted features and BYOK settings.

1. In Cursor's model/API-key settings, enable your own OpenAI-compatible connection.
2. Set the OpenAI Base URL override to https://api.memoryrouter.ai/v1.
3. Enter your Memory Key in the API Key field and select a model available through your MemoryRouter provider configuration.
4. Start a new local chat using that explicit model and run the cross-session proof.

Limit: BYOK does not mean every Cursor feature uses that endpoint. Do not infer coverage for Tab, Auto routing, background/cloud agents, or other hosted features. If the installed version cannot select a compatible custom model/URL, this proxy path is unavailable on that surface. A native Cursor memory plugin is not installed by these steps.

Troubleshooting: if the UI accepts the key but recall fails, verify the selected chat is actually using the custom connection rather than a hosted default. Do not disable enterprise policy to force it.

Cursor BYOK guidance

Windsurf

Windsurf is undergoing a transition to Devin Desktop. Legacy Cascade and newer agent surfaces have different capabilities. A generic claim that all Windsurf models support an arbitrary proxy URL is not supported by this guide.

For a legacy Cascade installation with remote MCP support:

1. Open Cascade's MCP settings and add a custom remote MCP server.
2. Set the server URL to https://mcp.memoryrouter.ai/mcp.
3. Complete OAuth if the host supports the server's authorization flow, select your vault, and enable its tools.
4. Ask Cascade explicitly to store or search a synthetic fact and inspect the tool result.

If editing the legacy MCP config directly, merge this entry into its existing mcpServers object rather than replacing other servers:

{
  "mcpServers": {
    "memoryrouter": {
      "serverUrl": "https://mcp.memoryrouter.ai/mcp"
    }
  }
}

Limit: this is conditional remote MCP compatibility, not a verified native plugin for Devin Local. If your release lacks compatible remote OAuth, stop at that boundary. Do not paste an API key into an OAuth client-secret field. A model selection screen or BYOK toggle alone does not prove custom-proxy support.

Troubleshooting: check the exact agent surface and its current MCP transport/auth support. Legacy Cascade's native Memories and Rules are separate from the external MemoryRouter vault.

Legacy Cascade MCP documentation · Memory migration boundaries

Cline

Cline is a coding agent extension with an explicit OpenAI-compatible provider configuration.

1. Open Cline settings and choose OpenAI Compatible as the API provider.
2. Set Base URL to https://api.memoryrouter.ai/v1.
3. Set API Key to your Memory Key.
4. Set Model ID to an available routed model such as openai/gpt-4.1, and configure the model's actual context/output capabilities.
5. Start a new task using this provider and run the proof below.

Limit: only traffic through that provider uses the proxy. Context size, tool calling, image support, and streaming must match the chosen model. This is not the dedicated hook filtering used by the Claude Code package; prefer :read when you only want recall.

Troubleshooting: verify the Model ID and provider settings rather than assuming a model selected elsewhere in the extension is used here.

Official OpenAI-compatible setup

Continue

Continue's public project has transitioned after acquisition by Cursor. Treat this as configuration for an existing compatible Continue installation or maintained fork, not a promise about a future product roadmap.

In a version using YAML configuration, merge a model entry into the existing models list:

models:
  - name: MemoryRouter
    provider: openai
    model: openai/gpt-4.1
    apiBase: https://api.memoryrouter.ai/v1
    apiKey: mk_your_key
    useResponsesApi: false

Replace the placeholder key through your installation's supported secret mechanism or a private local config, then select MemoryRouter in chat. Keep existing top-level schema/name/version fields. useResponsesApi: false selects the Chat Completions path for compatible versions.

Limit: this does not migrate existing Continue memory, configure every autocomplete model, or install a native plugin. A fork may have changed the schema; compare its documentation before copying the entry.

Troubleshooting: a request to an unexpected API path often means the client selected Responses instead of Chat Completions, or another configured model was chosen.

OpenAI provider configuration · Project status

Aider

Aider is a terminal coding assistant that supports an OpenAI-compatible endpoint through explicit environment variables.

export OPENAI_API_BASE='https://api.memoryrouter.ai/v1'
export OPENAI_API_KEY='mk_your_key:read'
aider --model openai/openai/gpt-4.1

The first openai/ selects Aider's OpenAI-compatible backend. The remaining openai/gpt-4.1 is the model name sent to MemoryRouter. Substitute a currently available model, preserving this distinction.

Limit: the read-only example recalls existing memory but stores no new coding session. Seed the proof from another writable client connected to the same vault. This configuration changes Aider's inference route and does not add a separate lifecycle capture plugin.

Troubleshooting: if the model is unknown, check both the client backend prefix and the routed model identifier. Check that the environment variables are set in the shell actually launching Aider.

Official OpenAI-compatible setup

Cody

Cody's Free, Pro, and Enterprise Starter offerings ended in 2025. This section is for an existing Sourcegraph Enterprise deployment with administrator-controlled modelConfiguration. It is not a consumer extension setting.

An administrator can add an OpenAI-compatible provider under Site config → modelConfiguration → providerOverrides. Merge this provider entry with existing configuration:

{
  "id": "memoryrouter",
  "displayName": "MemoryRouter",
  "serverSideConfig": {
    "type": "openaicompatible",
    "useLegacyCompletions": false,
    "endpoints": [
      {
        "url": "https://api.memoryrouter.ai/v1/",
        "accessToken": "mk_your_key:read"
      }
    ]
  }
}

Then add a matching modelOverrides entry using your selected model's actual capabilities and context limits:

• modelRef: memoryrouter::v1::gpt-4.1
• modelName: gpt-4.1
• serverSideConfig: { "type": "openaicompatible", "apiModel": "openai/gpt-4.1" }
• capabilities: include chat only if supported by the selected model and client.

Select that model in Cody chat or its defaultModels.chat configuration. Keep a valid existing autocomplete model rather than assuming this chat setup covers autocomplete. The useLegacyCompletions field requires a Sourcegraph version supporting it; use that version's schema validation.

Limit: this is a source-documented administrator configuration candidate, not a real-account-verified Cody integration. A site-wide access token points callers at one vault. Do not use a personal key for an entire enterprise or claim automatic user-level isolation. Test in a restricted deployment before rollout.

Troubleshooting: inspect Sourcegraph's effective model configuration and selected model reference. If chat silently falls back to another model, the request may never reach MemoryRouter.

Official model configuration · Provider examples

Zed

Zed supports OpenAI-compatible model endpoints for its built-in agent through provider configuration.

1. Open Zed settings and configure an OpenAI-compatible provider using the current API-access guide.
2. Set its api_url to https://api.memoryrouter.ai/v1 and add an available model such as openai/gpt-4.1, using the model's actual context limits.
3. Save your Memory Key through Zed's provider credential UI, not a committed settings file.
4. Select that provider/model in the built-in agent and run the proof below.

Limit: external agents launched through ACP own their authentication and model configuration separately. Configuring Zed's built-in provider does not configure Claude Code, Codex, or edit prediction. Use their dedicated guides where applicable.

Troubleshooting: confirm the conversation is with the built-in agent using the custom provider, not an external agent. An accepted editor configuration alone is not proof of memory recall.

Cross-session proof

Use a synthetic fact rather than real source code or secrets.

1. With a writable proxy credential, complete a chat saying: "The demo release phrase is ORCHID-7419." For MCP, explicitly request a store and approve it.
2. Allow background ingestion. For read-only clients, seed that same vault through a separate writable connection instead.
3. Open a fresh chat/task with no earlier transcript. Ask: "What is the demo release phrase I told you before?" Do not include the answer.
4. Confirm ORCHID-7419 is returned. For MCP, inspect the actual search result, not just the model's response.
5. Repeat from a second configured client to prove cross-tool recall. Both must authorize the same vault.

This procedure has not been executed in every listed client by this documentation update. Compatibility sources establish configuration surfaces, not a universal integration certification.

Shared limitations and troubleshooting

• A base URL cannot force hosted features or external agents to use it. Verify the actual request destination with credentials redacted.
• A shared Memory Key means a shared vault. Separate editor profiles do not automatically isolate users or repositories.
• Proxy mode sends routed inference content through MemoryRouter. MCP sends explicit tool inputs; lifecycle integrations have their own capture rules.
• 401/403: check vault credentials, provider credentials, scopes, and administrator policy. Stop retrying unchanged authentication failures.
• 404 or unsupported operation: check endpoint path, model prefix, API family, and streaming/tool support.
• Empty recall: confirm the fact was stored in the expected vault, allow ingestion time, and use a relevant question.
• Disable the custom provider or disconnect MCP to stop future use. This does not delete existing remote memories.

Next steps

View coding integrations · All integrations · Create an account