MCP Integration

Retriqs can expose your storages through MCP.

This allows an MCP-compatible client such as Claude Desktop to retrieve context from a Retriqs storage and use that context during a conversation.

The MCP integration is useful when you want another client to work with the knowledge graph and retrieval layer that already exists inside Retriqs.

Last updated: April 4, 2026

Prerequisites

Before using MCP with Retriqs, make sure:

  • the Retriqs desktop app is installed and running
  • you have created at least one storage
  • that storage already contains indexed content
  • the MCP server in Retriqs is running
  • your MCP client is configured to connect to the Retriqs endpoint

If you do not have a storage yet, create and configure one first, then upload and index your files before testing MCP.

What the MCP integration does

When the MCP server is running, an external MCP client can connect to Retriqs and access tools that work against your existing storages.

This means you can:

  • list the storages available in Retriqs
  • retrieve context from a specific storage
  • return retrieval results as plain text
  • return retrieval results as JSON
  • let another client use Retriqs as its retrieval layer

Important behavior

The main retrieval tools return context, not a final answer.

That means the MCP client should pass the returned context to its own model and generate the final answer there.

In practice, the flow looks like this:

  1. Retriqs retrieves context from the selected storage
  2. The MCP client receives that context
  3. The client model uses that context to answer the user

Claude Desktop example

One way to connect Claude Desktop is to add a Retriqs MCP entry to your claude_desktop_config.json.

Example:

{
  "mcpServers": {
    "retriqs-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "supergateway",
        "--streamableHttp",
        "http://127.0.0.1:9621/mcp/"
      ]
    }
  }
}

In this example, Claude Desktop connects to the local Retriqs MCP endpoint through supergateway.

Available tools

Retriqs currently exposes these MCP tools.

list_storages

Lists all available Retriqs storages.

Use this when the client needs to discover which storages exist before retrieving context.

retrieve_context

Retrieves context only from a Retriqs storage.

This tool does not generate the final answer.

The caller should pass the returned context to its own model.

If create_chat=true, the retrieval call is also saved into the Retriqs app chat history.

retrieve_context_json

Works like retrieve_context, but returns the result as a JSON string.

This can be useful when the MCP client or downstream workflow expects structured output.

query_storage

Deprecated alias for retrieve_context.

New integrations should use retrieve_context instead.

Recommended usage pattern

For most MCP clients, the recommended flow is:

  1. Connect to the Retriqs MCP server
  2. Run list_storages
  3. Choose the correct storage
  4. Run retrieve_context or retrieve_context_json
  5. Pass the returned context to the client model
  6. Let the client generate the final answer

This keeps Retriqs focused on retrieval while the connected client handles answer generation.

Example workflow

A simple example is to use a prebuilt graph from the Retriqs marketplace and connect it to Claude Desktop.

For example:

  1. Install the LangChain graph from the marketplace
  2. Start the Retriqs MCP server
  3. Configure Claude Desktop
  4. Ask a question about LangChain
  5. Claude Desktop uses Retriqs to retrieve context from the graph
  6. Claude Desktop writes the final answer using that retrieved context

This is one of the fastest ways to test the MCP integration because you do not need to build a graph from scratch first.

What the client receives

Depending on the tool used, the client receives:

  • retrieved context from the selected storage
  • storage-aware retrieval results
  • optionally structured JSON output
  • optional chat history creation inside Retriqs

The final answer still comes from the model used by the MCP client.

Notes and limitations

A few important points:

  • MCP depends on a running local Retriqs instance
  • the selected storage must already exist
  • the selected storage should already be indexed
  • retrieval quality depends on the quality of the graph and indexed content
  • query_storage is still available for compatibility, but should be treated as deprecated

Troubleshooting

If the MCP integration does not work as expected, check these things first:

  • Retriqs is open and running
  • the MCP server is started
  • the endpoint is reachable at http://127.0.0.1:9621/mcp/
  • Claude Desktop was restarted after changing the config
  • the selected storage actually exists
  • the storage contains indexed documents

If the connection works but answers are weak, the issue is usually not the MCP connection itself. In most cases, the problem is that the storage is empty, incomplete, or not yet indexed well enough for retrieval.

Suggested screenshot

A good screenshot for this page is a Claude Desktop conversation that uses the LangChain prebuilt graph through MCP.

The best version would show:

  • the user question
  • Claude Desktop answering
  • visible evidence that the Retriqs MCP tools were used

Suggested alt text:

Claude Desktop using the Retriqs MCP server to answer a question with context retrieved from a LangChain graph

Next step

Once MCP is connected, the next step is to make sure the storage you are querying is well configured and contains the right indexed content.

Related Pages

Retriqs is still evolving, and feedback from early users helps us decide what to improve next.

If you want to share ideas, report issues, suggest graph packs, or help test new features, join our Discord:

Join the Retriqs Discord