> ## Documentation Index
> Fetch the complete documentation index at: https://docs.elitea.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Elitea MCP Tools Internal Tool

> Let agents call other tagged agents and MCP-enabled toolkits directly from conversations, using ELITEA's built-in MCP server.

## Overview

**Elitea MCP Tools** is a built-in internal tool that connects a conversation agent to ELITEA's own **Model Context Protocol (MCP) server**. Once enabled, the agent can discover and call other agents and toolkit operations that have been explicitly made available through MCP — all from within a single conversation, without the user needing to pre-wire every dependency upfront.

<CardGroup cols={2}>
  <Card title="Platform-Native MCP Access" icon="server">
    Uses the same secure MCP server that external MCP clients use, but from inside a conversation — no separate connection needed.
  </Card>

  <Card title="Agent Invocation" icon="robot">
    Call other agents tagged with **mcp** as tools — pass a task, get back the agent's full response.
  </Card>

  <Card title="Toolkit Tool Execution" icon="toolbox">
    Invoke individual tools from any toolkit with **Available via MCP** enabled — each selected tool becomes a direct callable.
  </Card>

  <Card title="No External Credentials" icon="shield-check">
    Authentication is inherited from the current user session — no additional secrets or setup required.
  </Card>
</CardGroup>

<Tip title="When to Use Elitea MCP Tools">
  Use Elitea MCP Tools when you want a **coordinator or meta-agent** to discover and delegate to other agents at runtime — without hardcoding every child agent in the configuration. It's also the right choice when you need an agent to invoke toolkit operations dynamically, based on what the conversation requires.
</Tip>

***

## Prerequisites

* **MCP Enabled**: MCP features must be enabled on the platform. If the **Elitea MCP Tools** toggle does not appear in the Internal Tools list, contact your Elitea administrator.
* **Permission Level**: User role with conversation or agent edit access
* **Agents tagged with `mcp`**: To appear as callable tools, agents must have the **`mcp`** tag applied. Agents without this tag are not listed, regardless of publish status.
* **MCP-Available Toolkits** *(optional)*: Toolkits with **Available via MCP** enabled in their settings, so their individual tools are callable.

***

## How It Works

When Elitea MCP Tools is enabled, the agent connects to ELITEA's built-in MCP server, which exposes two types of callable resources:

| Category          | What Is Exposed                                                   | Requirement                                                        |
| ----------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------ |
| **Agents**        | Agents appear as tools the AI can call with a `task` argument     | Agent must have the **`mcp` tag** applied                          |
| **Toolkit Tools** | Each selected tool within a toolkit becomes a standalone callable | Toolkit must have **Available via MCP** enabled in its MCP Options |

**How a tool call works**

1. The agent decides to call a resource — for example, `PR_Review_Agent` with `task: "Review PR #42"`
2. The MCP server resolves the name and routes the call:
   * **Agent call** → runs the full agent prediction pipeline and returns the agent's final reply
   * **Toolkit tool call** → executes the tool with the provided arguments and returns the result as JSON
3. The response is returned to the calling agent, which incorporates it into its reasoning

<Info title="How Tool Names Are Generated">
  Both agent and toolkit tool names are derived from the resource's display name: any character that is not a letter, digit, underscore, or hyphen is replaced with `_`. For example, `"PR Review Agent"` → `PR_Review_Agent`, and `"My GitHub Toolkit"` with tool `create_issue` → `My_GitHub_Toolkit_create_issue`. Names that collide after normalisation — the second occurrence is silently skipped, so keep resource names distinct.
</Info>

***

## Enabling Elitea MCP Tools

Elitea MCP Tools can be toggled on per conversation or saved as part of an agent's configuration for persistent use across all conversations with that agent.

<Note>
  If **Elitea MCP Tools** does not appear in the Internal Tools list, the MCP feature may be disabled at the platform level. Contact your Elitea administrator.
</Note>

### In a Conversation

Enable Elitea MCP Tools for an ad-hoc conversation.

1. Navigate to your conversation.
2. Locate the chat input toolbar at the bottom of the screen.
3. Click the **`+`** icon in the toolbar to open the menu.
4. Hover over **Internal Tools** to reveal the flyout panel.
5. Find **Elitea MCP Tools** in the list and click the toggle to enable it.
6. A success toast notification appears: **"Internal tools configuration updated"**.
7. Click anywhere outside the panel to close it.

<img src="https://mintcdn.com/epam-a74ef051/Wzb1PyeRyE5QXbmK/img/how-tos/chat-conversations/internal-tools/elitea-mcp-tools/elitea-mcp-tools-chat.gif?s=31a6804f954a8abff5d17c6f90c177c6" alt="Elitea MCP Tools Access" width="1912" height="911" data-path="img/how-tos/chat-conversations/internal-tools/elitea-mcp-tools/elitea-mcp-tools-chat.gif" />

Once enabled, the agent has access to all MCP-exposed tools in that conversation. The agent can call them as needed based on the conversation flow and user instructions.

### In Agent Configuration

Configure Elitea MCP Tools as part of an agent's saved configuration so it is active for all new conversations using that agent.

1. Navigate to **Agents** in the main menu.
2. Select the agent you want to configure or create a new agent.
3. Within the TOOLS section, locate the **INTERNAL TOOLS** subsection.
4. Find the **Elitea MCP Tools** toggle. If it is not visible, click **Show all** to expand the full list.
5. Click the **Elitea MCP Tools** toggle to enable it.
6. Click **Save** at the top of the configuration page.
7. New conversations created with this agent will have Elitea MCP Tools active by default.

<img src="https://mintcdn.com/epam-a74ef051/Wzb1PyeRyE5QXbmK/img/how-tos/chat-conversations/internal-tools/elitea-mcp-tools/elitea-mcp-tools-agent.gif?s=49748ea1f58b73f1da90d1fb1279763f" alt="Elitea MCP Tools Access" width="1912" height="911" data-path="img/how-tos/chat-conversations/internal-tools/elitea-mcp-tools/elitea-mcp-tools-agent.gif" />

<Tip title="Combine With Smart Tools Selection">
  When many platform agents and toolkits are available, consider also enabling **Smart Tools Selection** to reduce token usage from binding all discovered tools upfront.
</Tip>

***

## Available Tools at Runtime

The exact tools the agent sees at runtime depend on your project's configuration.

### Agent Tools

Agents that have the **`mcp` tag** applied are exposed as callable tools. Each such agent produces one tool:

| Property        | Value                                                                                     |
| --------------- | ----------------------------------------------------------------------------------------- |
| **Name**        | Derived from the agent's display name — any character outside `[A-Za-z0-9_-]` becomes `_` |
| **Description** | The agent's description field                                                             |
| **Input**       | Single `task` string — a self-contained instruction; the agent receives no other context  |
| **Output**      | The agent's final text response                                                           |

<Warning title="Tag Your Agents">
  Agents without the **`mcp`** tag do **not** appear as tools, even if they are published. Apply the `mcp` tag to an agent in its settings to make it callable via Elitea MCP Tools.
</Warning>

### Toolkit Tools

Toolkits with **Available via MCP** turned on in their **MCP Options** section expose their selected tools individually:

| Property           | Value                                                                                         |
| ------------------ | --------------------------------------------------------------------------------------------- |
| **Name**           | `{toolkit_name}_{tool_name}` — both normalised with the same rule as above                    |
| **Description**    | `"Tool '{tool_name}' from toolkit type '{toolkit_type}'. Toolkit description: {description}"` |
| **Input / Output** | Matches the toolkit's native tool schema exactly                                              |

***

## Using Elitea MCP Tools

Once enabled, the agent automatically has access to all discovered tools. No additional prompting or configuration is needed — the agent uses them based on the task requirements.

### Example Interaction

**User:** *"List all open pull requests from the GitHub toolkit and ask the code review agent to review each one."*

**Setup required:**

* GitHub toolkit has **Available via MCP** enabled and `list_pull_requests` in its selected tools
* The code review agent has the **`mcp`** tag applied

**Behind the Scenes:**

1. The agent calls `My_GitHub_Toolkit_list_pull_requests` (normalised from `"My GitHub Toolkit"` + `list_pull_requests`) to fetch open PRs
2. For each PR, the agent calls `Code_Review_Agent` with a self-contained `task` that includes the PR title and diff inline
3. The code review agent runs its full prediction pipeline and returns its findings as text
4. The calling agent collects all reviews and presents a consolidated summary to the user

***

## Example Scenarios

<Accordion title="Dynamic Agent Coordinator">
  **Scenario:** A meta-agent that delegates tasks to specialised agents at runtime, without pre-wiring every dependency in the configuration.

  **Setup:**

  * Elitea MCP Tools: Enabled on the coordinator agent
  * `Reporting Agent` and `QA Agent` both have the **`mcp`** tag applied

  **User Request:**

  > `Summarise the last sprint and send the report through the reporting agent, then run the regression tests using the QA agent.`

  **Workflow:**

  1. Coordinator discovers available agent tools from the MCP server
  2. Calls `Reporting_Agent` with `task: "Generate a sprint summary for the last sprint. Include completed items, blockers, and carry-overs."`
  3. Receives the sprint report as text
  4. Calls `QA_Agent` with `task: "Run the regression test suite and return the pass/fail summary."`
  5. Receives the test results
  6. Combines both outputs and returns a single status update to the user

  The coordinator never needed hardcoded references to the child agents — adding a new agent with the `mcp` tag makes it immediately available.
</Accordion>

<Accordion title="Release Automation Agent">
  **Scenario:** A DevOps engineer wants an agent that bridges Jira and GitHub using natural language — finding tickets, merging their PRs, and updating statuses.

  **Setup:**

  * Elitea MCP Tools: Enabled
  * `Dev GitHub` toolkit — **Available via MCP** on; selected tools include `list_pull_requests`, `merge_pull_request`
  * `Project Jira` toolkit — **Available via MCP** on; selected tools include `search_issues`, `update_issue`

  **Exposed tool names** (after normalisation):

  * `Dev_GitHub_list_pull_requests`, `Dev_GitHub_merge_pull_request`
  * `Project_Jira_search_issues`, `Project_Jira_update_issue`

  **User Request:**

  > `Find all Jira tickets marked "Ready for Release" and merge the associated GitHub pull requests.`

  **Workflow:**

  1. Agent calls `Project_Jira_search_issues` with JQL `status = "Ready for Release"`
  2. For each ticket, extracts the linked PR number from the ticket fields
  3. Calls `Dev_GitHub_merge_pull_request` for each PR
  4. Calls `Project_Jira_update_issue` to transition each ticket to "Released"
  5. Returns a summary: merged PRs and updated Jira tickets
</Accordion>

<Accordion title="QA Coordinator Agent">
  **Scenario:** A QA team uses one coordinator agent to orchestrate test execution and bug filing across dedicated specialist agents and a Jira toolkit — all resolved at runtime.

  **Setup:**

  * Elitea MCP Tools: Enabled on the coordinator agent
  * `Test Runner Agent` — `mcp` tag applied; runs the test suite and returns results
  * `Failure Analysis Agent` — `mcp` tag applied; classifies failures as known regressions or new bugs
  * `QA Jira` toolkit — **Available via MCP** on; selected tools include `create_issue`

  **User Request:**

  > `Run today's regression suite, analyse any failures, and log new bugs.`

  **Workflow:**

  1. Coordinator calls `Test_Runner_Agent` with `task: "Run the full regression suite and return pass/fail per test case."`
  2. Agent receives structured results with failure details
  3. Coordinator calls `Failure_Analysis_Agent` with `task: "Classify the following failures as known regressions or new bugs: {failures_list}"`
  4. Analysis agent returns a categorised list
  5. For each new bug, coordinator calls `QA_Jira_create_issue` with the failure details
  6. Coordinator sends a final summary: tests run, failures found, bugs filed
</Accordion>

***

## Troubleshooting

<Accordion title="Elitea MCP Tools toggle is not visible in the Internal Tools list">
  The toggle only appears when MCP features are enabled at the platform level. Contact your Elitea administrator and ask them to enable **MCP exposure** and **MCP in menu** in the platform configuration.
</Accordion>

<Accordion title="No agent tools appear after enabling">
  Agents are only listed if they have the **`mcp`** tag applied. Publish status alone is not sufficient.

  To expose an agent:

  1. Open the agent in the **Agents** menu
  2. Go to the agent's settings and add the **`mcp`** tag
  3. Save the agent

  The agent will now appear as a tool when Elitea MCP Tools is enabled.
</Accordion>

<Accordion title="No toolkit tools appear after enabling">
  Toolkit tools are only exposed when the toolkit has **Available via MCP** enabled in its configuration. Go to **Toolkits**, open the toolkit, locate the **MCP Options** section, and enable the toggle. Only `selected_tools` within that toolkit will be exposed — verify the correct tools are selected.
</Accordion>

<Accordion title="The agent calls the wrong tool or gets confused by similar tool names">
  Tool names are derived from display names: any character outside `[A-Za-z0-9_-]` is replaced with `_`. If two resources produce the same normalised name, only the first is exposed and the second is silently skipped.

  Make names clearly distinct. For example, `"GitHub - Frontend Repo"` and `"GitHub - Backend Repo"` normalise to different names, while `"GitHub (Frontend)"` and `"GitHub Frontend"` both become `GitHub_Frontend_` and may collide.

  Rename conflicting agents or toolkits and verify the resulting normalised names are unique before relying on them.
</Accordion>

<Accordion title="Agent tool calls time out or return errors">
  Agent tool calls run the full agent prediction pipeline, which can take significant time for complex agents. If timeouts occur:

  * Ensure the target agent's LLM is healthy and its configuration is complete
  * Check if the target agent has its own toolkits that may be failing to initialise
  * Simplify the `task` argument — the called agent must be able to complete it independently
</Accordion>

<Accordion title="Toolkit tool calls return 'Access denied' or similar errors">
  Toolkit tool execution uses the current user's session credentials. Verify:

  * The user has access to the project containing the toolkit
  * The toolkit's stored credentials (API keys, tokens) are valid and not expired
  * The toolkit's **Available via MCP** option is still enabled
</Accordion>

***

## Related Features

<Info title="Additional Resources">
  * **[Expose Elitea Tools via MCP](../../integrations/mcp/make-tools-available-by-mcp)** - Enable toolkit tools for ELITEA's MCP server so they appear as callables when Elitea MCP Tools is active
  * **[Elitea MCP Server (SSE)](../../integrations/mcp/mcp-server-sse)** - Connect external MCP clients to ELITEA's built-in MCP server — the same server this feature uses internally
  * **[Smart Tools Selection](./smart-tools-selection-internal-tool)** - Reduce token usage when many agent and toolkit tools are available — pairs well with Elitea MCP Tools
  * **[Swarm Mode](./swarm-mode-internal-tool)** - Another multi-agent pattern for tightly coupled agent handoffs with shared context
  * **[Agent Publishing](../agents-pipelines/agent-publishing)** - Publish an agent version before tagging it with `mcp` to make it callable via Elitea MCP Tools
  * **[Remote MCP Servers](../../integrations/mcp/create-and-use-remote-mcp)** - Add external MCP servers to your project as toolkits, complementing the platform's built-in MCP capabilities
  * **[Agent Configuration](../../menus/agents)** - Creating and configuring agents
  * **[Conversation Management](../../menus/chat)** - Managing conversations and settings
</Info>