Model Context Protocol (MCP): Building LLM Agents with Tool Access

1. What is Model Context Protocol (MCP)?

The Problem It Solves

Traditional LLMs are stateless and isolated—they can't browse the web, interact with APIs, or perform actions beyond text generation. While tools like LangChain exist, they often require complex glue code for each integration.

MCP-Use provides a standardized way to:

• ✅ Connect any LLM (OpenAI, Anthropic, Groq, Llama) to any MCP server
• ✅ Enable tool calling without custom integration code
• ✅ Build autonomous agents that can execute multi-step workflows
• ✅ Support multiple servers simultaneously (web browsing + database + Blender)

Key Capabilities

2. Technical Architecture

Component Overview

┌─────────────────────────────────────────────────────────┐
│                       MCP-Use Agent                     │
│  ┌─────────────┐  ┌──────────────┐  ┌────────────────┐ │
│  │   LLM Core  │◄─┤ Tool Manager │◄─┤ Server Manager││
│  │ (LangChain) │  │              │  │                │ │
│  └─────────────┘  └──────────────┘  └────────────────┘ │
└─────────────────────────────────────────────────────────┘
           │                    │                  │
           ▼                    ▼                  ▼
    ┌────────────┐      ┌────────────┐     ┌──────────────┐
    │  OpenAI    │      │ Playwright │     │   Custom     │
    │  Anthropic │      │   Server   │     │  MCP Server  │
    │    Groq    │      │            │     │              │
    └────────────┘      └────────────┘     └──────────────┘

Core Components

1. LLM Flexibility

MCP-Use supports any LangChain-compatible LLM with tool calling:

• OpenAI: GPT-4o, GPT-4 Turbo (native function calling)
• Anthropic: Claude 3.5 Sonnet, Claude 3 Opus (tool use API)
• Open Source: Llama 3.3 70B, DeepSeek V3, Qwen (via vLLM/TGI)
• Cloud Providers: Groq, Together AI, Fireworks

2. Server Connection Methods

MCP supports multiple transport mechanisms:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"],
      "env": {"DISPLAY": ":1"}
    },
    "airbnb": {
      "command": "python",
      "args": ["-m", "mcp_airbnb"],
      "env": {}
    },
    "blender": {
      "command": "uvx",
      "args": ["blender-mcp"],
      "env": {"BLENDER_PATH": "/usr/bin/blender"}
    }
  }
}

3. Agent Capabilities

• 🔄 Dynamic server selection - Agent chooses which server to use
• 🛡️ Tool access control - Restrict specific tools per task
• 📊 Configurable max steps - Prevent infinite loops (default: 10)
• ⚡ Async streaming - Real-time output as agent works

3. Installation & Setup

Prerequisites

• Python 3.10+ (asyncio support required)
• Node.js 18+ (for npm-based MCP servers)
• LLM API key (OpenAI, Anthropic, or self-hosted endpoint)

Installation

# Install via pip
pip install mcp-use

# Or install from source
git clone https://github.com/mcp-use/mcp-use
cd mcp-use
pip install -e .

Environment Setup

# LLM Provider (choose one)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GROQ_API_KEY=gsk_...

# Or self-hosted
VLLM_ENDPOINT=http://localhost:8000/v1
VLLM_API_KEY=token-abc123

# Optional: Display for GUI apps
DISPLAY=:1

Installing MCP Servers

# Web browsing with Playwright
npm install -g @playwright/mcp

# Airbnb search
pip install mcp-airbnb

# Blender 3D modeling
pip install blender-mcp

# File system access
npm install -g @modelcontextprotocol/server-filesystem

4. Basic Usage Examples

Example 1: Web Research Agent

import asyncio
from mcp_use import MCPUse
from langchain_openai import ChatOpenAI

async def research_competitors():
    # Initialize MCP-Use with OpenAI
    agent = MCPUse(
        llm=ChatOpenAI(model="gpt-4o", temperature=0),
        config_path="mcp_config.json",  # Server configuration
        max_steps=10
    )

    # Execute research task
    result = await agent.run(
        task="Research the top 3 AI deployment platforms. "
             "For each, find: pricing, GPU support, and deployment speed. "
             "Create a comparison table.",
        stream=True  # Stream output in real-time
    )

    print(result)

# Run async
asyncio.run(research_competitors())

What happens under the hood:

1. Agent analyzes task → decides it needs web browsing
2. Selects Playwright MCP server from config
3. Navigates to competitor websites
4. Extracts pricing tables, feature lists
5. Synthesizes data into markdown table
6. Returns structured output

Example 2: Travel Planning with Airbnb

from mcp_use import MCPUse
from langchain_anthropic import ChatAnthropic

async def plan_trip():
    agent = MCPUse(
        llm=ChatAnthropic(model="claude-3-5-sonnet-20241022"),
        config_path="mcp_config.json"
    )

    result = await agent.run(
        task="Find 3 highly-rated apartments in Barcelona "
             "for 2 people, Feb 15-22, budget €800 total. "
             "Must have: WiFi, washer, near metro. "
             "Return with links and price breakdown."
    )

    print(result)

asyncio.run(plan_trip())

Agent workflow:

1. Connects to Airbnb MCP server
2. Searches with filters: location, dates, price, amenities
3. Retrieves listings with ratings
4. Filters by subway proximity (uses map data)
5. Returns top 3 with detailed breakdown

Example 3: 3D Asset Generation with Blender

from mcp_use import MCPUse
from langchain_groq import ChatGroq

async def generate_3d_model():
    agent = MCPUse(
        llm=ChatGroq(model="llama-3.3-70b-versatile"),
        config_path="mcp_config.json"
    )

    result = await agent.run(
        task="Create a 3D model of a futuristic spaceship. "
             "Add metallic materials, neon blue accents. "
             "Export as FBX for Unreal Engine."
    )

    print(result)

asyncio.run(generate_3d_model())

5. Advanced Agent Patterns

Multi-Server Orchestration

Combine multiple MCP servers in a single workflow:

config = {
    "mcpServers": {
        "web": {
            "command": "npx",
            "args": ["@playwright/mcp@latest"]
        },
        "database": {
            "command": "python",
            "args": ["-m", "mcp_postgres"],
            "env": {"DB_URL": "postgresql://..."}
        },
        "slack": {
            "command": "npx",
            "args": ["@slack/mcp"]
        }
    }
}

agent = MCPUse(llm=llm, config=config)

result = await agent.run(
    task="Monitor our competitor's pricing page every hour. "
         "If prices drop >10%, log to database and notify #sales on Slack."
)

Tool Access Control

Restrict which tools the agent can use:

agent = MCPUse(
    llm=llm,
    config_path="mcp_config.json",
    allowed_tools=[
        "playwright_navigate",
        "playwright_screenshot",
        "playwright_extract_text"
    ],  # Block file write, code execution
    max_steps=5  # Limit iterations
)

Streaming with Progress Updates

async for event in agent.stream(task="Research AI news"):
    if event.type == "tool_call":
        print(f"🔧 Using tool: {event.tool_name}")
    elif event.type == "thought":
        print(f"💭 Thinking: {event.content}")
    elif event.type == "result":
        print(f"✅ Result: {event.content}")

6. Production Considerations

Error Handling & Retry Logic

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
async def run_agent_with_retry(task: str):
    try:
        agent = MCPUse(llm=llm, config_path="mcp_config.json")
        return await agent.run(task, timeout=300)  # 5 min timeout
    except Exception as e:
        logger.error(f"Agent failed: {e}")
        raise

Cost Optimization

Security Best Practices

• 🔒 Sandbox MCP servers - Run in Docker containers with limited permissions
• 🛡️ Validate tool inputs - Prevent injection attacks in SQL/shell commands
• 📝 Audit logs - Track all tool calls, especially file writes and API requests
• 🔐 Secret management - Use Vault/AWS Secrets Manager, never hardcode keys

Monitoring & Observability

from opentelemetry import trace
from prometheus_client import Counter, Histogram

# Metrics
agent_requests = Counter('agent_requests_total', 'Total agent requests')
agent_duration = Histogram('agent_duration_seconds', 'Agent execution time')
tool_calls = Counter('tool_calls_total', 'Tool calls', ['tool_name'])

# Tracing
tracer = trace.get_tracer(__name__)

async def monitored_agent_run(task: str):
    with tracer.start_as_current_span("agent_execution"):
        agent_requests.inc()
        with agent_duration.time():
            result = await agent.run(task)
            # Track tool usage
            for tool in result.tools_used:
                tool_calls.labels(tool_name=tool).inc()
            return result

7. Real-World Use Cases

1. Competitive Intelligence Automation

2. Customer Support Automation

3. Content Pipeline Automation

4. DevOps Incident Response

8. MCP vs Other Agent Frameworks

When to Choose MCP

• ✅ Need to connect multiple specialized tools (web + DB + APIs)
• ✅ Want LLM flexibility (switch between OpenAI/Anthropic/self-hosted)
• ✅ Building production agents with reliability requirements
• ✅ Need standardized server protocol for team collaboration

When to Use Alternatives

• ⚠️ Simple single-tool tasks → Use LangChain directly
• ⚠️ Multi-agent collaboration → Use CrewAI
• ⚠️ Desktop GUI automation → Use Anthropic Computer Use

9. Conclusion

Model Context Protocol (MCP) represents a significant step forward in LLM agent development. By standardizing how models interact with external tools, it enables developers to build sophisticated, multi-capability agents without reinventing integration logic.

Key Takeaways

• 🎯 Standardization wins - MCP's protocol approach beats custom integrations
• 🔧 Tool diversity - From web scraping to 3D modeling, MCP servers cover it all
• 💰 Cost control - Smart caching and model selection reduce bills by 60-90%
• 🏢 Production-ready - Error handling, monitoring, and security are built-in concerns

Next Steps

1. Start small - Build a single-server agent (Playwright for web research)
2. Add complexity - Combine 2-3 servers for multi-step workflows
3. Optimize costs - Switch to self-hosted Llama 3.3 70B for tool calling
4. Monitor & iterate - Track metrics, improve prompts, expand capabilities