Getting Started with Agent-CoreX: A Practical Walkthrough

This guide walks through every part of Agent-CoreX from scratch — creating an account, enabling MCP servers, calling the retrieval API, and monitoring your usage.

What Agent-CoreX Does

Agent-CoreX sits between your application and your MCP servers. It provides:

• A marketplace of MCP servers you can browse and enable from the dashboard
• A retrieval API that selects only the tools relevant to a given query, reducing the tokens you pass to your LLM
• A Playground for testing tool retrieval and execution interactively
• Custom Packs for grouping tools into domain-specific bundles

Step 1: Create an Account

Go to agentcorex.com. You can sign up with email/password or OAuth (Google, GitHub). No credit card required on the free plan.

After signup, you're taken directly to the dashboard.

Step 2: Create an API Key

Go to Dashboard → API Keys and click Create API Key. Give it a name (e.g., development) and copy the key.

Store it securely — it won't be shown again. For local development, put it in .env.local. For production, use your environment's secret manager.

# .env.local
ACX_API_KEY=acx_xxxxxxxxxxxxxxxxxx
ACX_API_BASE=https://api.agentcorex.com  # check your dashboard for the current base URL

Step 3: Enable MCP Servers

Go to Dashboard → MCP Servers. The Marketplace tab shows all available servers organized by category:

• Developer Tools — GitHub, file system, terminal access
• Databases — PostgreSQL, SQLite, and others
• Web — Brave Search, Puppeteer
• Communication — Slack and messaging tools
• Productivity — calendar and task management

Each card has a detail drawer with:

• What the server does
• Which tools it exposes and what they accept
• Required environment variables / configuration
• 1-click install buttons for VS Code, VS Code Insiders, and Cursor
• CLI install command you can copy directly

Click Enable on any server to add it to your account. Enabled servers appear in the My Servers tab, where you can toggle them on or off at any time.

Step 4: Test in the Playground

Before writing any integration code, verify your setup in Dashboard → Playground.

The Playground has two modes:

Semantic search — type a query and see which tools are retrieved. This is exactly what the /retrieve_tools API will return for that query. You can see the relevance scores alongside each tool.

All tools — browse every tool from your enabled servers, expand each one to see its schema, and run it directly with test arguments. The JSON result is shown inline.

Use the Playground to:

• Confirm your servers are enabled and their tools are indexed
• Tune how many tools (top_k) you want returned for different query types
• Test tool execution before building the full agent loop

Step 5: Call the Retrieval API

Once you're satisfied with the Playground results, call the same endpoint from your code:

// Retrieve tools relevant to a query
const res = await fetch(
  `${ACX_API_BASE}/retrieve_tools?query=${encodeURIComponent(query)}&top_k=5`,
  { headers: { Authorization: `Bearer ${ACX_API_KEY}` } }
)
const { tools } = await res.json()

// Pass the filtered tools to Claude
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,
  messages: [{ role: "user", content: query }],
})

Step 6: Execute Tool Calls

When Claude responds with stop_reason: "tool_use", execute the tool through Agent-CoreX:

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

  const execRes = 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 toolResult = await execRes.json()

  // Continue the conversation with the tool result
  // ... send tool_result back to Claude
}

Step 7: Monitor Usage

Dashboard → Usage shows:

• Queries used vs. your plan's limit
• A breakdown of tool calls by server
• Usage over time

If you're approaching your plan's limit, you can upgrade from Dashboard → Billing.

Step 8: Create Custom Packs

As your setup grows, Dashboard → Custom Packs lets you group MCP servers into named bundles — for example, a pack that contains only your database and file system servers for data-focused workflows.

Custom packs let you:

• Narrow retrieval scope — search for tools within a specific pack rather than all enabled servers
• Register custom MCP servers — add servers not in the marketplace by providing their npx, uvx, or docker install command and environment variables
• Install packs with a single command — each pack has a generated agent-corex install-pack {packId} command

Pack limits depend on your plan: Free and Starter get 1 pack, Pro gets 5, Team gets unlimited.

Plan Overview

See full plan details

Summary

The core Agent-CoreX workflow is:

1. Enable servers in the MCP marketplace
2. Retrieve relevant tools per query via /retrieve_tools
3. Execute tool calls via /execute_tool
4. Monitor usage and tune top_k over time

Start in the Playground to build intuition before writing any code — it shows you exactly what the API will return for your queries and lets you run tools directly.

Create your free account →