Supported models

MemoryRouter stores conversational memory separately from the model producing the next answer. A supported model can retrieve relevant context from the same vault across sessions. Switching models does not require importing that vault again.

There are two integration paths:

• Proxy API: MemoryRouter retrieves memory, forwards your model request, and captures supported conversation text.
• Local inference: your application calls MemoryRouter for retrieval and storage, while you call your model provider directly. This also supports a local model or a gateway you control.

The public model page is a compatibility overview. Provider access, billing, endpoint format, and the provider's current model availability still determine whether a particular request can run.

Prerequisites

• A MemoryRouter account and an active Memory Key.
• For proxy inference, a valid provider API key with access and billing for the chosen model. A ChatGPT or Claude consumer subscription is not automatically a provider API credential.
• An HTTP client or compatible SDK. The runnable example below uses Python 3 and the OpenAI Python SDK.
• A dedicated test vault for the synthetic verification. Reuse the same vault across both processes.

You can configure supported provider credentials in the MemoryRouter dashboard, or use the proxy's BYOK headers. Do not send provider credentials to the memory-only endpoints when your application calls the provider directly.

1. Choose the endpoint, not just the model name

MemoryRouter also has an OpenAI-compatible translation path for Anthropic and Gemini, but translated requests are not a guarantee that every provider-native feature survives unchanged. Prefer the native endpoint when you need native tools, thinking fields, response blocks, or streaming semantics.

For a router or provider format you already manage, use local inference instead of assuming an arbitrary custom base URL is reachable or supported by the hosted proxy.

2. Inspect your account's catalog

With your Memory Key supplied privately in MEMORYROUTER_API_KEY:

curl --fail-with-body https://api.memoryrouter.ai/v1/models \
  -H "Authorization: Bearer $MEMORYROUTER_API_KEY"

The response contains:

This endpoint reads a catalog snapshot and configured provider keys. It does not call every provider to validate your live entitlement. It is not an exhaustive inventory of every direct-provider route, BYOK credential, or private runtime. An empty list can mean no supported dashboard provider key is configured, even when you plan to supply a provider key through BYOK headers.

Use the provider's current model documentation to confirm model access and endpoint support. Do not infer that a retired model still works because it appears in an older catalog.

3. Set up a proxy client

Install the SDK:

python3 -m pip install --upgrade openai

Supply MEMORYROUTER_API_KEY and OPENAI_API_KEY through your local secret manager or a private shell environment. Neither key belongs in the script, repository, prompt, or screenshot.

Save this as memory-model-proof.py:

import os
import sys
from openai import OpenAI

if len(sys.argv) != 2 or sys.argv[1] not in {"remember", "recall"}:
    raise SystemExit("Usage: python3 memory-model-proof.py remember|recall")

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
    base_url="https://api.memoryrouter.ai/v1",
    default_headers={"X-Memory-Key": os.environ["MEMORYROUTER_API_KEY"]},
)

prompt = (
    "Remember this synthetic project fact: for the fictional Cedar launch, "
    "the review phrase is copper-orbit-482. Confirm the test fact."
    if sys.argv[1] == "remember"
    else "What was the review phrase for the fictional Cedar launch? "
    "Use retrieved memory, and say if it is unavailable."
)

response = client.chat.completions.create(
    model=os.environ.get("MR_MODEL", "openai/gpt-4.1-mini"),
    messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)

The provider key goes in the SDK's normal authorization header. X-Memory-Key identifies the MemoryRouter vault. The example omits a session partition so both processes use the same core vault.

Cross-session proof

Run the write conversation:

python3 memory-model-proof.py remember

After the stored exchange becomes searchable, launch a new process with no earlier chat messages:

python3 memory-model-proof.py recall

The second process sends only the question, not the expected answer copper-orbit-482. Count the proof when it returns that phrase from retrieved memory. If it does not, confirm the fact exists with a MemoryRouter search before retrying. A successful model response by itself does not prove memory was stored or retrieved.

To test another OpenAI-compatible model on the same configured provider, set MR_MODEL to an available model ID and repeat only recall. For a different provider, change the credential and client endpoint/body appropriately. Do not reuse an OpenAI key as an Anthropic, Gemini, or OpenRouter key.

Limitations

• Model support does not include the provider's inference cost or bypass account access restrictions, usage limits, or deprecations.
• Proxy support is endpoint-specific. A chat model listing does not imply support for every provider API, such as image generation, audio, realtime, batch, or embeddings.
• Model output is probabilistic. Relevant retrieval improves continuity but does not guarantee the model follows every retrieved fact.
• MemoryRouter retrieval does not enlarge the model's context window. Retrieved memory still consumes input context.
• The same Memory Key, embedding selection, and retrieval scope must be used to share memory. Deliberately isolated project/session scopes do not become shared merely because a model changes.
• Memory-only mode still sends the text you submit for retrieval/storage to MemoryRouter. Keeping inference local is not the same as keeping all conversation data on-device.

Troubleshooting

Next steps

• Explore supported models
• Supported models in the integrations directory
• Proxy setup and headers
• Bring your own inference stack
• Create your MemoryRouter account