Skip to main content

MCP Integration

MCP (Model Context Protocol) is an open standard for connecting LLMs to external tool servers. MCP servers expose tools (functions) that agents can call during their reasoning process — just like built-in capabilities, but from any external source.

Assign MCP servers to an agent, and at runtime TARX connects to those servers, discovers their tools, and makes them available to the LLM alongside any built-in capabilities.

What MCP Means for Agents​

Without MCP, your agents can use 5 built-in capabilities (web search, code exec, etc.). With MCP, your agents gain access to unlimited external tools:

  • GitHub MCP server: Read repos, create PRs, review diffs, manage issues
  • Jira MCP server: Create/update tickets, search issues, add comments
  • Salesforce MCP server: Query leads, update opportunities, log activities
  • Slack MCP server: Send messages, read channels, create posts
  • Database MCP server: Query PostgreSQL, MongoDB, or any database
  • Custom MCP server: Your own internal APIs and systems

The LLM sees MCP tools alongside capability tools — it decides which to call based on the task.

How MCP Works at Runtime​

The process:

  1. Executor connects to each assigned MCP server via the MCP protocol (HTTP/stdio)
  2. Performs the initialization handshake
  3. Discovers the list of available tools with their schemas
  4. Adds those tools to the LLM's tool list
  5. When the LLM calls an MCP tool, the executor forwards the call to the MCP server
  6. The MCP server executes the tool and returns the result
  7. The result is passed back to the LLM as a tool result

Connecting MCP Servers​

MCP servers must be connected to your project before you can assign them to agents. This is done in the MCP Servers section of your project.

MCP Hub layout:

  • Top section (Connected): MCP servers already connected to your project — shows name, tool count, and who connected it (Connected by @username)
  • Bottom section (Add MCP Server): Catalog of available MCP providers + Custom MCP entry form

Adding from the Catalog​

  1. Click MCP Servers in the sidebar.
  2. Scroll the Add MCP Server section to find a provider (GitHub, Jira, etc.).
  3. Click the provider card.
  4. Fill in the required config (authentication token, API key, etc.).
  5. Click Connect.
  6. The MCP server appears in the Connected section with a tool count.

Adding a Custom MCP Server​

For internal or custom MCP servers:

  1. In the Add MCP Server section, click Custom MCP.
  2. Fill in:
    • Name: Display name for this server instance
    • URL: The MCP server endpoint (HTTP-based MCP) or command (stdio-based)
    • Auth: Bearer token, API key, or no auth
  3. Click Connect.

TARX validates the connection by performing the MCP handshake. If it fails, an error message shows what went wrong.

Multiple Instances​

You can connect multiple instances of the same provider — for example, two GitHub MCP connections for different organizations. Each instance has its own auth token and shows independently in the Connected list.

Duplicate URL warning

If you connect a second MCP server with the same URL as an existing one, TARX shows a soft warning ("This URL is already connected"). You can proceed — it's valid to have two instances with the same URL but different auth tokens.

Assigning MCP Servers to Agents​

In the Agent Editor, Section 7 (MCP Servers):

  1. Click Add MCP Server.
  2. A dropdown shows all MCP servers connected to your project.
  3. Select the server.
  4. Repeat for additional servers.

The agent now has access to all tools from all assigned MCP servers. There is no limit on how many MCP servers you can assign.

Tool Discovery and Naming​

When an agent runs, TARX discovers tools from each MCP server. Tool names follow this pattern:

{mcp_server_name}__{tool_name}

For example, a GitHub MCP server named github with a create_pr tool becomes:

github__create_pr

The LLM sees this name when deciding which tool to call. Write your system prompt to use these tool names if you need to guide the model:

When asked to create a pull request, use the github__create_pr tool.
Always list available repositories first with github__list_repos.

GitHub MCP​

Common tools:

  • list_repos — List repositories accessible to the token
  • get_file_contents — Read file content from a repo
  • create_or_update_file — Write/update a file in a repo
  • create_branch — Create a new branch
  • create_pull_request — Open a PR
  • list_issues — List repo issues
  • create_issue — Open a new issue
  • search_code — Search across repos

Filesystem MCP​

Common tools:

  • read_file — Read file content
  • write_file — Write content to file
  • list_directory — List directory contents
  • create_directory — Create a directory
  • move_file — Move or rename a file

Slack MCP​

Common tools:

  • send_message — Send a message to a channel
  • list_channels — List available channels
  • get_channel_history — Read recent messages

Database MCP (PostgreSQL/SQLite)​

Common tools:

  • query — Execute a SELECT query
  • list_tables — List available tables
  • describe_table — Get column schema for a table

System Prompt Guidance for MCP Agents​

When your agent uses MCP tools, help it understand when and how to use them:

You have access to a GitHub repository via MCP tools. Use them to:
- Read existing code before making changes
- Always create a new branch for changes (never commit to main)
- Create pull requests with clear titles and descriptions that explain the change

Workflow:
1. List repos if you don't know the repo name
2. Read relevant files to understand the existing code
3. Create a branch: github__create_branch
4. Make changes: github__create_or_update_file
5. Create PR: github__create_pull_request with a clear title and description

Security Considerations​

Credential Storage​

MCP server credentials (API tokens, OAuth tokens) are stored as project credentials in TARX — encrypted at rest, the same as user API keys. Only project admins can add or delete MCP servers.

Network Access​

MCP server connections are made from the TARX backend. If your MCP server is internal (behind a firewall), you'll need to either:

  1. Allow TARX's outbound IP in your firewall (contact support for the current range)
  2. Use a VPN tunnel (not currently native — future feature)
  3. Run a public-facing MCP server behind an auth layer

Scope Your Tokens​

When creating tokens for MCP servers, use the minimum required permissions:

  • GitHub: If the agent only reads, use a read-only token
  • Jira: If the agent only creates issues, scope to issue creation
  • Never use admin-level tokens unless the agent genuinely needs admin access

Building Your Own MCP Server​

If you have internal APIs that agents should access, you can build an MCP server and connect it as a custom MCP. MCP is an open protocol with SDKs for:

  • Python: mcp package from Anthropic
  • TypeScript: @modelcontextprotocol/sdk

An MCP server in Python looks like:

from mcp import Server, Tool

server = Server("my-internal-api")

@server.tool("get_customer_info")
async def get_customer_info(customer_id: str) -> dict:
    """Get customer information by ID"""
    # Call your internal API
    return await internal_api.get_customer(customer_id)

@server.tool("update_ticket_status")
async def update_ticket_status(ticket_id: str, status: str) -> dict:
    """Update support ticket status"""
    return await ticket_system.update_status(ticket_id, status)

# Serve via HTTP
server.run_http(port=3001)

Deploy this server, expose it (with auth), and connect it as a Custom MCP in TARX.

See Connecting MCP Servers for the full setup guide.

Last updated on