How to Use MCP with Claude via Agent-CoreX

Model Context Protocol (MCP) is the open standard that lets AI models like Claude connect to external tools and data sources — databases, file systems, APIs, and more. Agent-CoreX makes managing those MCP connections simple with a built-in marketplace and a semantic retrieval API that cuts token waste.

What is MCP?

MCP defines a standard way for an AI model to discover and call external tools. Instead of hard-coding integrations, any tool that implements the MCP spec can be plugged in and used by any compatible model.

Think of it like USB-C for AI — one standard, infinite compatibility.

How Agent-CoreX Works with MCP

Agent-CoreX provides two things on top of raw MCP:

1. A marketplace — browse and enable MCP servers directly from your dashboard
2. A retrieval API — given a user query, it returns only the relevant tools (not all of them)

This means you never have to manually decide which of your enabled servers are relevant to a specific query. The API does that for you.

Step 1: Create an Account and Get Your API Key

Sign up at agentcorex.com. After logging in, go to Dashboard → API Keys and create a new key. Copy it — you'll use it in every API call.

# Store it somewhere safe — treat it like a password
ACX_API_KEY=acx_xxxxxxxxxxxxxxxxxx

Step 2: Browse the MCP Marketplace

Go to Dashboard → MCP Servers. You'll see the full marketplace with categories like:

• Developer Tools — GitHub, file system, terminal
• Databases — PostgreSQL, SQLite, MySQL
• Web — Brave Search, Puppeteer, web scraping
• Productivity — calendars, notes, task managers
• Communication — Slack, email

Each server card shows:

• What the server does and which tools it exposes
• 1-click install buttons for VS Code, VS Code Insiders, and Cursor
• CLI install instructions
• Required and optional configuration (environment variables, paths)

Click Enable on any server to add it to your account.

Step 3: Retrieve Relevant Tools for a Query

Once you have servers enabled, use the /retrieve_tools endpoint to get only the tools relevant to a specific user query:

const response = await fetch(
  `${ACX_API_BASE}/retrieve_tools?query=${encodeURIComponent(userQuery)}&top_k=5`,
  {
    headers: {
      Authorization: `Bearer ${ACX_API_KEY}`,
    },
  }
)

const { tools } = await response.json()
// tools is an array of MCP tool definitions — ready to pass to Claude

The top_k parameter controls the maximum number of tools returned. For most queries, 3–5 is enough. This is where the token savings come from: instead of passing all your enabled tools to Claude, you pass only the ones that matter for this query.

Step 4: Call Claude with the Filtered Tools

Pass the retrieved tools directly to Claude's messages API:

import Anthropic from "@anthropic-ai/sdk"

const anthropic = new Anthropic()

const message = await anthropic.messages.create({
  model: "claude-opus-4-5",
  max_tokens: 1024,
  tools: tools,  // only the relevant ones from /retrieve_tools
  messages: [{ role: "user", content: userQuery }],
})

Claude sees a focused, minimal toolset and responds more accurately with less context noise.

Step 5: Execute Tool Calls

When Claude decides to use a tool, execute it via the /execute_tool endpoint:

if (message.stop_reason === "tool_use") {
  const toolUse = message.content.find(block => block.type === "tool_use")

  const execResponse = await fetch(`${ACX_API_BASE}/execute_tool`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${ACX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      tool: toolUse.name,
      args: toolUse.input,
    }),
  })

  const result = await execResponse.json()
  // Feed result back to Claude as a tool_result message
}

Agent-CoreX routes the execution to the correct MCP server, handles the protocol, and returns the result.

Test It in the Playground

Before integrating into your codebase, try it out in Dashboard → Playground. The Playground lets you:

• Enter a query and see which tools are retrieved
• Inspect each tool's description, parameters, and schema
• Run tools directly and view the JSON output
• Switch between semantic search and browsing all installed tools

It's the fastest way to verify your server setup and understand which tools get selected for different queries.

Organize Tools with Custom Packs

For larger setups, Dashboard → Custom Packs lets you group MCP servers into domain-specific bundles — for example, a "data-pack" with your database and file system servers, or a "comms-pack" with Slack and email.

Packs help the retrieval API narrow its search space, which improves both accuracy and speed.

Next Steps

• Dashboard → MCP Servers — enable servers for your use case
• Dashboard → Playground — test tool retrieval interactively
• Dashboard → Custom Packs — organize tools into logical groups
• Create a free account — no credit card required