Using MCP in Claude

Using MCP in LLM Calls - With Claude

Unlocking Claude’s Potential with MCP

Large Language Models (LLMs) like Anthropic’s Claude are incredibly powerful, but their knowledge is often limited to the data they were trained on and they typically lack direct access to real-time information or private data sources. They also can’t inherently perform actions in external systems. The Model Context Protocol (MCP) provides a standardized way to supercharge Claude by connecting it to a world of external data and tools, making its responses more accurate, relevant, and actionable.

Think of MCP as a universal adapter. Claude can ‘talk’ to this adapter (via your application) to get the latest information or to ask for tasks to be done, without needing to know the nitty-gritty details of each data source or tool.

Bridging Claude to External Data via MCP

MCP allows you to define ‘resources’ on an MCP server. These resources can be anything from documents in a file system, records in a database, information from a company’s internal API, or real-time data like weather updates. When your application interacts with Claude and needs to ground its responses in specific, current, or proprietary data, it can query an MCP client.

The flow is simple: Your application, before calling Claude, determines that contextual data is needed. It requests this data from an MCP server (via an MCP client). The MCP server fetches the data (e.g., a customer’s latest support ticket details) and returns it in a structured format. Your application then incorporates this data into the prompt sent to Claude, enabling Claude to generate a well-informed response.

Example Data Sources: Project documents, user profiles, product catalogs, knowledge base articles, real-time news feeds.

Empowering Claude with External Tools through MCP

Beyond just fetching data, LLMs often need to perform actions. MCP defines ‘tools’ that an LLM can request to use. These tools represent capabilities like sending an email, booking a meeting, querying a database, or even running a piece of code. When Claude, in its interaction, determines an action is required, your application can translate this intent into an MCP tool execution request.

For instance, if a user asks Claude to summarize a lengthy document and then email the summary, Claude might first process the document (provided as a resource via MCP). Then, it might indicate the need to use an ‘email’ tool. Your application would then use an MCP client to call the ‘email’ tool on an MCP server, passing the summary and recipient details. The MCP server handles the actual email sending. The result of the tool execution (e.g., ‘email sent successfully’) can then be passed back to Claude to confirm the action to the user.

Example Tools: Sending notifications, creating calendar events, executing database queries, interacting with version control systems.

Illustrative Scenario: MCP in Action with Claude

Imagine a sophisticated AI assistant powered by Claude, designed to help with project management. Here’s how MCP would enhance its capabilities:

User Request: User asks, “Claude, what are the pending tasks for the ‘Phoenix Project’ and can you notify Alex about the critical ones?”
Data Retrieval (MCP Resource): The application recognizes the need for project data. It uses an MCP client to request the ‘project_tasks’ resource from an MCP server connected to your project management system. Example MCP call (conceptual): mcp_client.get_resource(server_id='project_management_system', resource_path='/projects/Phoenix/tasks?status=pending').
Contextual Prompt for Claude: The fetched task list (e.g., [{'id': 'task1', 'desc': 'Design UI', 'priority': 'high'}, {'id': 'task2', 'desc': 'Backend API', 'priority': 'critical'}]) is formatted and included in the prompt to Claude: “Here are the pending tasks for Project Phoenix: […task list…]. Please identify critical tasks and formulate a notification for Alex.”
Claude’s Processing & Tool Indication: Claude processes the information and identifies ‘task2’ as critical. It then formulates a notification message and indicates the need to use a ‘send_notification’ tool. This indication might be a structured output or a specific textual cue that your application is designed to understand.
Tool Execution (MCP Tool): Your application parses Claude’s response. It then uses the MCP client to call the ‘send_notification’ tool on an MCP server that integrates with your communication platform. Example MCP call (conceptual): mcp_client.execute_tool(server_id='communication_hub', tool_id='send_slack_dm', params={'user': 'Alex', 'message': 'Critical task update for Project Phoenix: Backend API needs attention.'}).
Result & Final Response: The MCP server executes the tool, and the result (e.g., {'status': 'success', 'message_id': 'slack123'}) is returned to the application. This result can be fed back to Claude, which then formulates a final response to the user: “I’ve found the pending tasks. The critical task ‘Backend API’ has been identified, and I’ve sent a notification to Alex about it.”

# Conceptual Python-like example for application logic

# mcp_client and claude_client are assumed to be initialized

# --- Phase 1: Fetching data using MCP for Claude ---
def get_project_tasks_for_claude(project_name):
    try:
        tasks = mcp_client.get_resource(
            server_id='project_management_system',
            resource_path=f'/projects/{project_name}/tasks?status=pending'
        )
        return f"Here are the pending tasks for {project_name}: {tasks}"
    except MCPError as e:
        print(f"MCP Error fetching tasks: {e}")
        return f"Sorry, I couldn't retrieve tasks for {project_name}."

user_query = "What are the pending tasks for the 'Phoenix Project' and can you notify Alex about the critical ones?"
project_name = "Phoenix Project" # Extracted from user_query

context_from_mcp = get_project_tasks_for_claude(project_name)

# claude_response_object = claude_client.complete(
#     prompt=f"{context_from_mcp}\n\nUser instruction: {user_query}. Please identify critical tasks and formulate a notification for Alex. If a notification is needed, please indicate to use 'send_notification_tool' with parameters 'user' and 'message'."
# )
# claude_text_response = claude_response_object.completion
# tool_call_request = parse_claude_for_tool_call(claude_text_response) # Hypothetical parsing function

# --- Phase 2: Claude indicates tool use, executed via MCP ---
# Let's assume claude_response leads to this (application logic):
tool_call_request = {
    'tool_name': 'send_notification_tool',
    'params': {'user': 'Alex', 'message': 'Critical task update for Project Phoenix: Backend API needs attention.'}
}

if tool_call_request and tool_call_request['tool_name'] == 'send_notification_tool':
    try:
        tool_result = mcp_client.execute_tool(
            server_id='communication_hub',
            tool_id='send_slack_dm', # This ID is defined by the MCP server
            params=tool_call_request['params']
        )
        print(f"Tool execution result: {tool_result}")
        # final_prompt_to_claude = f"Notification sent to {tool_call_request['params']['user']} with result: {tool_result}. Please confirm to the user."
        # final_user_response = claude_client.complete(prompt=final_prompt_to_claude).completion
        # print(final_user_response)
    except MCPError as e:
        print(f"MCP Tool Error: {e}")
        # Inform Claude or user about the tool failure

This scenario demonstrates how MCP acts as a vital intermediary, allowing Claude to interact with external systems in a structured and secure manner, significantly expanding its utility.