DEV Community: Hanieh Zahiremami

The Developer's Guide to AI Agent Frameworks in 2025: MCP-Native vs Traditional Approaches

Hanieh Zahiremami — Fri, 21 Nov 2025 06:41:24 +0000

A technical comparison of 7 frameworks for building production AI agents, with honest trade-offs and code examples

There are too many AI agent frameworks. I've spent the last few months building with most of them at LastMile AI, and here's what I've learned: the "best" framework depends entirely on what you're building and how you want to build it.

This isn't a marketing piece. It's a technical breakdown of what each framework actually does well, where it falls short, and when you should use it.

The Quick Decision Matrix

Use Case	Framework	Why
MCP-native development	mcp-agent	Built for MCP from day one
Visual debugging	LangGraph	Studio with time-travel debugging
Multi-agent conversations	AG2	Agents coordinate autonomously
Type safety	PydanticAI	Full Pydantic validation + A2A support
Rapid prototyping	CrewAI	No-code Studio interface
OpenAI ecosystem	OpenAI Agents SDK	Native integration, hosted MCP
Google Cloud / Vertex AI	Google ADK	Powers Agentspace, bidirectional streaming

1. mcp-agent

GitHub: lastmile-ai/mcp-agent (~7.7k ⭐) | Python

A framework built specifically for Model Context Protocol. Not an adapter bolted on later—MCP is the foundation.

What It Does Well

Full MCP implementation — Tools, resources, prompts, notifications, OAuth, sampling, elicitation, roots. The whole spec.
Automatic durable execution — One config line switches to Temporal. No manual checkpointing, no workflow DSL to learn.
Implements Anthropic's patterns — Every pattern from Building Effective Agents plus OpenAI's Swarm pattern, all composable.
Cloud deployment — uvx mcp-agent deploy my-agent and you're running on managed infrastructure.

Code Example

from mcp_agent.app import MCPApp
from mcp_agent.agents.agent import Agent
from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM

# Temporal-backed durability in one line
app = MCPApp(name="researcher", execution_engine="temporal")

async def main():
    async with app.run():
        agent = Agent(
            name="researcher",
            server_names=["brave-search", "filesystem"],
            instruction="Research and compile reports"
        )
        async with agent:
            llm = await agent.attach_llm(OpenAIAugmentedLLM)
            result = await llm.generate_str("Summarize the latest AI news")
            print(result)

Use When

Building for the MCP ecosystem
You need durable execution without infrastructure complexity
You want Temporal reliability for long-running tasks
You prefer writing Python over graph DSLs

Skip If

You need visual debugging tools (use LangGraph Studio)
You're not using MCP servers

2. LangGraph

GitHub: langchain-ai/langgraph (~21.7k ⭐) | Python, JavaScript

Graph-based orchestration with best-in-class visual debugging. LangGraph 1.0 shipped in October 2025—the first stable major release in this space.

What's New in 1.0

Node/task caching — Cache individual node results to skip redundant computation
Deferred nodes — Delay execution until all upstream paths complete (great for map-reduce)
Pre/post model hooks — Add logic before/after model calls for guardrails
LangGraph Platform GA — 1-click deployment, memory APIs, human-in-the-loop

Code Example

from langgraph.graph import StateGraph
from langgraph.checkpoint.sqlite import SqliteSaver

workflow = StateGraph(AgentState)
workflow.add_node("research", research_function)
workflow.add_node("analyze", analyze_function)

workflow.add_conditional_edges(
    "research",
    should_continue,
    {"analyze": "analyze", "end": END}
)

# Checkpointing for durability
checkpointer = SqliteSaver.from_conn_string(":memory:")
app = workflow.compile(checkpointer=checkpointer)

Use When

You need visual debugging of workflow execution
Building complex branching logic
Your team values explicit state management
You want mature observability via LangSmith

Skip If

Simple workflows (LangGraph is overkill)
You prefer code over graph abstractions

3. AG2 (formerly AutoGen)

GitHub: ag2ai/ag2 (~3.8k ⭐) | Python

Conversational multi-agent framework. This is where it gets complicated: AG2 is the community-driven continuation of AutoGen 0.2, maintained by the original creators who left Microsoft. Microsoft's AutoGen 0.4 is a complete architectural rewrite heading toward Semantic Kernel integration.

Important context: If you're choosing between AG2 and Microsoft's AutoGen, know they're diverging. AG2 keeps the familiar architecture. Microsoft's version is getting a ground-up rewrite with TypeScript support, distributed agents, and deeper Azure integration.

Code Example

from autogen import ConversableAgent, LLMConfig

llm_config = LLMConfig.from_json(path="OAI_CONFIG_LIST")

coder = ConversableAgent(
    name="coder",
    system_message="You write Python code",
    llm_config=llm_config
)

reviewer = ConversableAgent(
    name="reviewer", 
    system_message="You review code quality"
)

result = coder.initiate_chat(reviewer, message="Build a REST API")

Use When

Multi-agent conversations fit your problem
You want agents to coordinate autonomously
You need the no-code AutoGen Studio interface

Skip If

You need deterministic workflow control
You want Microsoft ecosystem integration (wait for AutoGen 0.4)

4. PydanticAI

GitHub: pydantic/pydantic-ai | Python

Type-safe agents with Pydantic validation. Built by the Pydantic team—the same validation layer used by OpenAI SDK, Anthropic SDK, LangChain, and basically every Python AI library.

What's New

A2A (Agent-to-Agent) support — Not just MCP, but Google's agent interoperability protocol too
Durable execution — Agents preserve progress across API failures and restarts
Human-in-the-loop approval — Flag tool calls that need approval before proceeding
Streamed structured outputs — Real-time validation as data generates

Code Example

from pydantic import BaseModel
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio

class SearchResult(BaseModel):
    title: str
    url: str
    relevance_score: float

server = MCPServerStdio('uv', args=['run', 'mcp-server-fetch'])

agent = Agent(
    'openai:gpt-4o',
    result_type=SearchResult,
    toolsets=[server]
)

result = agent.run_sync('Search for AI framework comparisons')
# result.data is guaranteed to be SearchResult

Use When

Type safety prevents production bugs in your context
Building systems requiring schema compliance
Your team already uses FastAPI/Pydantic
You need both MCP and A2A protocol support

Skip If

Type safety isn't a priority for your use case
You need visual debugging

5. CrewAI

GitHub: crewAIInc/crewAI | Python

Orchestrates agents through Crews (autonomous) and Flows (event-driven). CrewAI has significantly improved their MCP support—it's no longer "limited."

MCP Integration (Updated)

from crewai import Agent, Task, Crew
from crewai.mcp import MCPServerStdio, MCPServerHTTP

research_agent = Agent(
    role="Research Analyst",
    goal="Find and analyze information",
    backstory="Expert researcher with access to multiple data sources",
    mcps=[
        # String reference for quick setup
        "https://mcp.exa.ai/mcp?api_key=your_key",
        # Or structured config for full control
        MCPServerStdio(
            command="python",
            args=["local_server.py"],
            env={"API_KEY": "your_key"}
        )
    ]
)

crew = Crew(
    agents=[research_agent],
    tasks=[research_task],
    process=Process.sequential
)

result = crew.kickoff()

Use When

You need both autonomous agents AND workflow control
Rapid prototyping with CrewAI Studio
Team includes non-technical members who need the visual builder

Skip If

You need the deepest MCP-native architecture

6. OpenAI Agents SDK

GitHub: openai/openai-agents-python | Python, JavaScript

OpenAI's official framework, released March 2025. Lightweight and opinionated—provides just enough structure without heavyweight abstractions.

Key Features

Hosted MCP tools — OpenAI manages the infrastructure, you just point to a URL
Local MCP servers — Full control when you need it
Handoffs — Agents delegate to specialized sub-agents
Guardrails — Enforce constraints on agent behavior
Built-in tracing — Observability out of the box

Code Example

from agents import Agent, Runner, HostedMCPTool

agent = Agent(
    name="Assistant",
    tools=[
        HostedMCPTool(
            tool_config={
                "type": "mcp",
                "server_label": "gitmcp",
                "server_url": "https://gitmcp.io/openai/codex",
                "require_approval": "never"
            }
        )
    ]
)

result = await Runner.run(agent, "What language is this repo written in?")
print(result.final_output)

Use When

You're already in the OpenAI ecosystem
You want hosted MCP without managing infrastructure
You need handoffs between specialized agents

Skip If

You need model-agnostic architecture
You want deeper control over MCP server lifecycle

7. Google ADK (Agent Development Kit)

GitHub: google/adk-python | Python

Google's open-source framework, announced at Cloud NEXT 2025. This is the same framework powering Agentspace and Google Customer Engagement Suite.

Key Features

Bidirectional streaming — Real-time audio and video with agents
Model agnostic — Gemini, Vertex AI Model Garden, or any LiteLLM-supported model
MCP Toolbox for Databases — Pre-built, production-ready tools for BigQuery, AlloyDB, Spanner, Cloud SQL
A2A Protocol support — Google's agent interoperability standard

Code Example

from google.adk import Agent
from google.adk.tools import MCPToolset

# Connect to MCP server
mcp_tools = MCPToolset.from_server(
    command="npx",
    args=["-y", "@anthropic/mcp-server-youtube"]
)

agent = Agent(
    name="research_agent",
    model="gemini-2.0-flash",
    tools=[mcp_tools],
    instruction="You are a research assistant with YouTube access"
)

response = await agent.generate("Find videos about MCP protocol")

Use When

You're building on Google Cloud / Vertex AI
You need bidirectional audio/video streaming
You want enterprise database integrations out of the box

Skip If

You're not in the Google ecosystem
You need the simplest possible setup

Feature Comparison (Updated December 2025)

Feature	mcp-agent	LangGraph	AG2	PydanticAI	CrewAI	OpenAI SDK	Google ADK
MCP Native	✅	Integration	Integration	✅	✅	✅ Hosted	✅
A2A Support	❌	❌	❌	✅	❌	❌	✅
Durability	Automatic	Configure	Manual	Automatic	Manual	Manual	Manual
Visual Debug	Temporal UI	✅ Studio	Studio	Logfire	Studio	Tracing	Dev UI
Type Safety	Standard	Standard	Standard	✅ Full	Standard	Standard	Standard
No-Code	❌	Studio	Studio	❌	✅ Studio	❌	❌
Streaming	✅	✅	✅	✅	✅	✅	✅ Bidirectional

Why MCP Matters in 2025

Model Context Protocol launched in November 2024. Here's where we are now:

Who's adopted it:

Anthropic — Creator, built into Claude
OpenAI — Official adoption March 2025, hosted MCP in Agents SDK
Google — ADK includes MCP Toolbox, full protocol support
Microsoft — Integrated into Azure AI
GitHub, Cursor, VS Code — MCP support shipped
Hundreds of community MCP servers

Native vs. Adapter:

Frameworks built for MCP (mcp-agent, PydanticAI, OpenAI SDK, Google ADK) work directly with the protocol. When new MCP capabilities ship, they work immediately.

Frameworks that added MCP later use adapter layers. They work, but there's an abstraction cost.

The Practical Benefit:

Hundreds of MCP servers exist for filesystems, databases, APIs, and internal tools. Native MCP support means you use them without writing integration code.

Decision Framework

By Use Case

Building with MCP? → mcp-agent (native) or PydanticAI (native + A2A)

Need visual debugging? → LangGraph Studio

Conversational multi-agent? → AG2

Type safety critical? → PydanticAI

Rapid prototyping? → CrewAI Studio

OpenAI ecosystem? → OpenAI Agents SDK

Google Cloud? → Google ADK

By Technical Requirement

Simplest durable execution:

# mcp-agent - one line
app = MCPApp(execution_engine="temporal")

Most control over durability:

# LangGraph - explicit checkpointing
checkpointer = SqliteSaver.from_conn_string(":memory:")
app = workflow.compile(checkpointer=checkpointer)

Complex workflows:

Graph-based → LangGraph
Code-based → mcp-agent
Conversational → AG2

By Team

Small startup: mcp-agent (less boilerplate) or CrewAI (rapid iteration)
Enterprise: LangGraph (mature observability) or Google ADK (GCP integration)
Non-technical stakeholders: CrewAI Studio or AutoGen Studio

Production Considerations

Observability Options

Framework	Tool	What You Get
LangGraph	LangSmith	Comprehensive tracing, evals
PydanticAI	Logfire	Real-time monitoring, MCP server included
mcp-agent	Temporal UI	Execution visibility, workflow debugging
CrewAI	Built-in	Monitoring and metrics
OpenAI SDK	Built-in tracing	Token usage, latency, errors
Google ADK	Cloud Monitoring	GCP-native observability

What to Track

Token usage and costs
Latency per tool call
Tool call success/failure rates
Decision paths through workflows

The Bottom Line

If you're starting fresh in 2025:

MCP support matters — Less integration code, better interoperability, future-proof as the protocol evolves
Pick based on your constraints — Team size, existing stack, debugging needs, and whether you need visual tools
Don't over-engineer — If a single agent with a few MCP servers solves your problem, you don't need multi-agent orchestration

The frameworks that will win long-term are the ones building for open protocols (MCP, A2A) rather than proprietary integrations. That's where interoperability lives.

Getting Started

mcp-agent: docs.mcp-agent.com | uvx mcp-agent init
LangGraph: langchain-ai.github.io/langgraph
AG2: docs.ag2.ai
PydanticAI: ai.pydantic.dev
CrewAI: docs.crewai.com
OpenAI Agents SDK: openai.github.io/openai-agents-python
Google ADK: google.github.io/adk-docs

Building something with these frameworks? I'd love to hear what's working (or not) — find me on LinkedIn or Twitter/X.

🚀 How to Build and Deploy ChatGPT Apps with MCP Servers

Hanieh Zahiremami — Wed, 12 Nov 2025 17:46:22 +0000

Deploy MCP servers to build agentic ChatGPT applications. This guide covers MCP server deployment architecture, best practices, and why specialized infrastructure matters.

TL;DR

MCP servers extend ChatGPT with tools, resources, and custom UI
Generic platforms require manual WebSocket config, asset bundling, and state management
MCP Agent Cloud (MCP-C) provides native MCP protocol support with 5-minute deploys
Follow this guide to deploy your first MCP server and connect it to ChatGPT

Why Deploy MCP Servers?

Deploying MCP servers transforms ChatGPT from a conversational interface into an agentic platform capable of:

Calling external APIs and databases autonomously
Rendering interactive UI components inside chat
Maintaining context across multi-turn conversations
Executing complex workflows on behalf of users

The deployment challenge: MCP protocol requires WebSocket handling, widget asset optimization, and persistent state management—capabilities not standard in typical hosting platforms.

🏗️ ChatGPT App Architecture

ChatGPT Apps consist of two main components:

1. MCP Server

Handles authentication, provides tools/prompts/resources, and serves the app's UI

2. Web Client

HTML, JavaScript, and CSS that renders inside ChatGPT

┌─────────────┐
│   ChatGPT   │
│  Interface  │
└──────┬──────┘
       │ connects to
       ▼
┌─────────────┐      serves assets
│ MCP Server  │ ───────────────────► Web Client renders
│             │                       inside ChatGPT
└─────────────┘

The ChatGPT interface connects directly to your MCP Server. The server either sends assets directly or returns a URL to the Web Client. Once loaded, the Web Client's content renders inside ChatGPT for user interaction.

🔧 What MCP Servers Provide

MCP servers extend ChatGPT with three key capabilities:

Capability	Description
Tools	Functions ChatGPT can call autonomously
Resources	UI templates and data that render in chat
Prompts	Predefined conversational patterns

When you deploy an MCP server, you're giving ChatGPT the ability to interact with external systems while maintaining conversational context.

🎯 Design Principles for ChatGPT Apps

The best ChatGPT apps help people accomplish something meaningful through a combination of chat with visual and interactive elements.

Good use cases: Ride booking, ordering food, tracking deliveries

According to OpenAI's design guidelines, successful ChatGPT apps follow these principles:

Conversational

Experiences should feel like a natural extension of ChatGPT, fitting seamlessly into the conversational flow and UI.

Intelligent

Tools should be aware of conversation context, supporting and anticipating user intent. Responses and UI should feel individually relevant.

Simple

Each interaction should focus on a single clear action or outcome. Information and UI should be reduced to the absolute minimum to support the context.

Responsive

Tools should feel fast and lightweight, enhancing conversation rather than overwhelming it.

Accessible

Designs must support a wide range of users, including those who rely on assistive technologies.

⚠️ MCP Server Deployment Challenges

Deploying MCP servers isn't straightforward on generic platforms:

MCP protocol requires specific WebSocket handling
ChatGPT widget assets need bundling and CDN delivery
State management across conversation turns
Authentication for multi-user scenarios
Real-time monitoring for agentic behavior

The problem: These aren't standard features in typical hosting platforms.

📁 Recommended Project Structure

A production ChatGPT app built with MCP servers typically follows this structure:

chatgpt-app/
├── server.py          # MCP server implementation
├── mcp.json           # Deployment configuration
├── widgets/           # HTML templates for ChatGPT UI
│   └── chart.html
├── static/            # JavaScript and CSS assets
│   ├── app.js
│   └── styles.css
└── tools/             # Tool implementations
    └── analytics.py

Step 1: Build the Web Assets

The server serves these assets via FastMCP resources.

Tip: For initial iteration, you can inline HTML/JS inside the MCP resource, but packaging static files yields better caching.

Example widget HTML (widgets/chart.html):

<!DOCTYPE html>
<html>
<head>
    <script src="/static/app.js"></script>
    <link rel="stylesheet" href="/static/styles.css">
</head>
<body>
    <div id="chart-container"></div>
</body>
</html>

Step 2: Define Widget Metadata

ChatGPT Apps understand OpenAI-specific tool annotations. When your tool returns EmbeddedResource metadata, ChatGPT hydrates the widget using the referenced HTML template.

Example tool with widget metadata:

🚢 Deploy MCP Servers: Three Approaches

Option 1: Self-Hosted

Configure everything manually: MCP protocol handlers, WebSocket servers, asset bundling, scaling logic.

Pros: Full control

Cons: High setup cost, ongoing maintenance

Option 2: Generic PaaS

Use platforms like Heroku or Railway. Still requires manual MCP configuration and ChatGPT-specific optimizations.

Pros: Easier than self-hosting

Cons: Moderate setup time, manual optimization needed

Option 3: MCP Agent Cloud

Purpose-built for MCP servers. Native protocol support, automatic ChatGPT integration, built-in asset optimization.

Pros: 5-minute deploys, built specifically for MCP

Cons: Less customization than self-hosted

☁️ How to Deploy MCP Servers with MCP Agent Cloud

MCP-C is infrastructure designed specifically for MCP server deployment.

Configuration

Create a simple mcp.json file:

{
  "name": "analytics-agent",
  "main": "server.py",
  "runtime": "python:3.11",
  "scaling": {
    "min_instances": 0,
    "max_instances": 10
  }
}

Deployment

Two commands. That's it:

# Install CLI
npm install -g @mcp-agent/cli

# Deploy
mcp-c deploy

What MCP-C handles automatically:

SSL certificates for secure connections
Global CDN for widget assets
WebSocket connection management
Auto-scaling based on usage
Environment variable management

Monitoring

Stay on top of your app's performance:

# Real-time logs
mcp-c logs your-app --follow

# Usage metrics
mcp-c metrics your-app

# Debug specific interactions
mcp-c trace --request-id abc123

💻 Building Your MCP Server

Core Implementation

Every MCP server needs these components:

Component	Purpose
Tool registration	Define functions ChatGPT can call
Resource handlers	Serve UI templates and data
Widget metadata	OpenAI-specific rendering instructions

Example Structure

Here's a complete example showing how tools and resources work together:

from fastmcp import FastMCP

mcp = FastMCP("Analytics Agent")

@mcp.tool()
async def get_metrics(metric_type: str):
    """Fetch analytics data and return with widget"""
    data = fetch_from_database(metric_type)

    return {
        "content": [
            {
                "type": "resource",
                "resource": {
                    "uri": "widget://chart",
                    "mimeType": "text/html",
                    "text": generate_chart_html(data)
                }
            }
        ]
    }

@mcp.resource("widget://chart")
async def chart_template():
    """Serve the chart widget HTML template"""
    with open("widgets/chart.html") as f:
        return f.read()

Step 3: Testing Your App

Before deployment, test your MCP server locally using MCP Inspector:

# Install dependencies
npm install -g @modelcontextprotocol/inspector

# Start your MCP server
python server.py  # Server runs on port 8000

# In another terminal, run MCP Inspector
mcp-inspector http://localhost:8000

In MCP Inspector:

Click Tools > List Tools to see available tools
Click Resources > List Resources to see widget HTML templates
Run a tool to see the widget metadata and structured result

Verify everything works:

Tool discovery works correctly
Resources load properly
Widget metadata validates
Static assets (JS/CSS) serve from http://127.0.0.1:8000/static

🔒 MCP Server Deployment Best Practices

Security

Validate all inputs from ChatGPT
Use environment variables for secrets
Implement rate limiting
Configure CORS properly

Performance

Keep widget payloads under 100KB
Use efficient database queries
Implement caching where appropriate
Monitor response times

Error Handling

Return user-friendly error messages
Log errors for debugging
Provide graceful fallbacks
Monitor error rates

💡 Common Use Cases

Data Analysis Agents

Deploy dashboards and visualizations directly in ChatGPT. Users query data conversationally, see results rendered as interactive charts.

Workflow Automation Agents

Connect to project management tools, CRMs, or internal systems. ChatGPT becomes an interface for triggering actions and checking status.

Customer Support Agents

Integrate helpdesk systems, knowledge bases, and ticket management. Support queries get resolved within the conversation.

📊 MCP Server Deployment Comparison

Aspect	Self-Hosted	Generic PaaS	MCP-C
MCP Protocol Setup	Manual configuration	Manual configuration	Native support
ChatGPT Integration	Build yourself	Build yourself	Automatic
Widget Asset Handling	DIY bundling + CDN	DIY bundling + CDN	Built-in
WebSocket Management	Configure yourself	Configure yourself	Handled
Deployment Time	Hours	30-60 minutes	~5 minutes
Ongoing Maintenance	High	Moderate	Low

🎬 Getting Started

Quick Start with Example Projects

The MCP Agent repository includes complete ChatGPT app examples to get you started:

Step 1: Clone the example repository

git clone https://github.com/lastmile-ai/mcp-agent
cd mcp-agent/examples/cloud/chatgpt_apps

Step 2: Install dependencies

npm install
pip install -r requirements.txt

Step 3: Test locally (see Testing section above)

Step 4: Deploy to MCP Agent Cloud

npm install -g @mcp-agent/cli
mcp-c deploy

Step 5: Connect to ChatGPT

Open ChatGPT GPT Builder
Add your MCP server URL from deployment
Test your app's tools and widgets

Learning Resources

Full Documentation: docs.mcp-agent.com
Cloud Deployment Guide: docs.mcp-agent.com/cloud/use-cases/build-chatgpt-apps
Example Code: github.com/lastmile-ai/mcp-agent
MCP Inspector: Debug and test locally

🎯 Why This Matters

MCP servers transform ChatGPT from a conversational interface into an agentic platform. The deployment infrastructure determines whether you spend time building features or managing servers.

Choose your approach based on:

Control needs

Self-host if you need custom infrastructure

Development speed

Use specialized platforms to ship faster

Maintenance capacity

Consider long-term operational costs

Key insight: MCP servers have specific requirements—WebSocket handling, widget asset delivery, state management—that generic platforms weren't designed to handle.

FAQ: Deploy MCP Servers

Q: What is an MCP server?

A: An MCP server implements the Model Context Protocol to extend ChatGPT with custom tools, resources, and UI components.

Q: Can I deploy MCP servers on any cloud platform?

A: Yes, but you'll need to manually configure WebSocket support, asset bundling, and state management. Purpose-built platforms like MCP-C handle this automatically.

Q: How long does it take to deploy an MCP server?

A: On MCP Agent Cloud: ~5 minutes. On generic PaaS: 30-60 minutes. Self-hosted: several hours for initial setup.

Q: What's the difference between MCP servers and regular APIs?

A: MCP servers provide tools (functions), resources (UI templates), and prompts that ChatGPT can use autonomously. Regular APIs just return data.

Q: Do I need to know the MCP protocol to deploy MCP servers?

A: Not with frameworks like FastMCP. They handle protocol implementation. You just define tools and resources.

Q: How do I test MCP servers before deploying?

A: Use MCP Inspector to test locally. It lets you verify tool discovery, resource loading, and widget rendering.

Tags: #MCP #MCPServer #ChatGPT #AgenticAI #Deployment #ModelContextProtocol

🚀 Hosting ChatGPT Apps on the Cloud

Hanieh Zahiremami — Tue, 21 Oct 2025 16:36:13 +0000

You can now deploy and host ChatGPT Apps on mcp-agent cloud, our MCP-native platform.

No complex infra. No manual setup. Just write your app, connect it, and deploy in minutes.

Your browser does not support the video tag.

💬 What Are ChatGPT Apps

ChatGPT Apps let you create interactive experiences that live inside ChatGPT conversations.

Apps can connect to APIs, databases, or services and respond with in-chat UI elements such as maps, charts, or playlists.

ChatGPT Apps are powered by the Model Context Protocol (MCP), which allows ChatGPT to talk directly to external services through a structured interface.

⚙️ What is mcp-agent

mcp-agent is an open-source toolkit and hosting platform for developers building MCP servers and ChatGPT Apps.

It helps you:

Build and run MCP servers locally or in the cloud
Simplify connection between your ChatGPT App and backend
Manage deployment, logging, and configuration automatically

In short, mcp-agent is the bridge between your Python app and ChatGPT.

With mcp-agent cloud, you can host your MCP server and get a public endpoint ready for ChatGPT in minutes.

🧠 Quick Start: Deploy Your ChatGPT App

TL;DR

Create an MCPApp() in your Python server code
Install the mcp-agent library
Deploy with the mcp-agent CLI

1️⃣ Prerequisites

Python 3.10+

2️⃣ Install Dependencies

Using uv (recommended):

uv init
uv sync

Or with pip:

pip install mcp-agent
pip install fastapi

3️⃣ Create an MCPApp()

MCPApp is what connects your MCP server to mcp-agent cloud.

Here’s a minimal example:

from mcp_agent.app import MCPApp
from fastmcp import FastMCP  # import if your project uses FastMCP

mcp = FastMCP(
    name="your-app-name",
    message_path="/sse/messages",  # aligns with your SSE path
    stateless_http=True,           # recommended for cloud hosting
)

## Register your MCP server as an mcp-agent App
app = MCPApp(
    name="your-app-name",
    description="your-app-description",
    mcp=mcp,
)

## Your ChatGPT Application code here

These few lines are what make your app discoverable and deployable by mcp-agent cloud.

4️⃣ Add Deployment Config and Secrets

At your repo root, create two files:

mcp_agent.config.yaml

execution_engine: asyncio

name: "your-app-name"
description: "your-app-description"

logger:
  transports: [console, file]
  level: info
  path: logs/mcp-agent.log

mcp_agent.secrets.yaml

## Optional: include API keys, tokens, or secrets here

5️⃣ Deploy to mcp-agent Cloud

Using uv:

uv run mcp-agent login
uv run mcp-agent deploy --no-auth

Or with venv:

mcp-agent login
mcp-agent deploy --no-auth

Support for OAuth coming soon

After a successful deploy, you’ll see a cloud URL like:

https://<deployment-id>.deployments.mcp-agent.com/sse

6️⃣ Connect to ChatGPT

Enable Developer Mode in ChatGPT
Go to Settings → Connectors
Add your app’s cloud URL (make sure it ends with /sse)

ChatGPT connects to the /sse endpoint, so that suffix is required.

🧰 Troubleshooting

404 or Connection Errors:

Make sure your URL ends with /sse and your app’s message_path is /sse/messages.

Auth Errors:

If deploy fails, run mcp-agent login.

If ChatGPT can’t connect, make sure you deployed with --no-auth for open access.

Debugging:

Use MCP Inspector to test and validate your MCP server locally.

🧩 Example Projects

❤️ Wrapping Up

ChatGPT Apps are a new way to create interactive, conversational tools that live right inside ChatGPT.

With mcp-agent cloud, deploying one is as simple as:

mcp-agent deploy --no-auth

And just like that, your ChatGPT App is live and ready for anyone to use.

Automate Research & Analysis Workflows Across Any Domain with `mcp-agent`

Hanieh Zahiremami — Tue, 29 Jul 2025 16:17:25 +0000

I’ve been using this agentic framework to automate both personal and work-related research, everything from analyzing real estate deals and comparing healthcare options to doing deep dives for product marketing, like competitor analysis or market sizing. It’s saved me tons of time by offloading the data pulling, cross-checking, and report writing to agents that actually get the job done.

So I built a universal research agent on top of mcp-agent a framework that lets you coordinate tools, APIs, memory, and LLM calls in one streamlined workflow.

It’s modular, agentic, and fully customizable for any domain.

⚙️ What it does

This framework gives you an end-to-end research pipeline:

Pluggable MCP Servers for your domain’s APIs (think finance, real estate, PubMed, etc.)
Automatic elicitation to ask the right questions before researching
Evaluator agent to make sure the final report meets your quality standards
Web search fallback when APIs fail or miss something
Domain-specific analysis with insights, calculations, and summaries
Markdown report writer that actually sounds smart

🧠 How it works

Here’s the architecture under the hood and how to run it:

1. Clone the repo

git clone https://github.com/lastmile-ai/mcp-agent.git
cd mcp-agent/examples/usecases/mcp_research_agent
uv init && uv sync
uv add mcp-agent fastmcp aiohttp
npm i -g g-search-mcp @modelcontextprotocol/server-filesystem

2. Set your API keys

Copy the secrets template and add your keys for your preferred domain:

openai:
  api_key: "sk-..."
environment:
  BLOOMBERG_API_KEY: "..."

3. Configure your servers

In mcp_agent.config.yaml, set up:

Your domain’s custom MCP server
Web search fallback (g-search)
Filesystem server for saving reports

4. Customize agent instructions

Swap in your domain and goals:

instruction = f"""You are a {{DOMAIN}} research expert.
Use tools to gather data, fallback to web if needed.
Focus on {{INSIGHT_TYPE}} and make recommendations."""

5. Run it like this:

uv run main.py "Austin real estate"
uv run main.py "AAPL earnings analysis"
uv run main.py "diabetes treatment comparison"

✨ Why it’s cool

Auto-elicitation: Agents ask for user preferences up front
Evaluator agent: Iterates until the report meets brand/tone/quality
Built-in fallback: If APIs fail, web search steps in
Composable: Plug in any tool or data source, adapt to any industry
Markdown reports: Clean and structured output for your team

🚀 Build your own agent

Want to do legal research? Healthcare summaries? Market analysis?

All you need to change are:

The agent instructions
Your custom MCP server
API integrations and schemas

Everything else stays the same.

👉 The code is here: https://github.com/lastmile-ai/mcp-agent/tree/main/examples/usecases/mcp_research_agent

If you’re into automating research, orchestrating APIs, or just hate writing the same analysis reports over and over, this one’s for you.

Would love to hear what domain you’d apply this to. Drop it in the comments! 💬

🛠️ Build Your First AI Agent

Hanieh Zahiremami — Thu, 29 May 2025 21:17:33 +0000

We’ve seen a lot of excitement around AI agents—but most tutorials focus on text generation and chat interfaces. What if you want your agents to actually do things? Automate tasks? Connect to tools like GitHub, Slack, or a local database?

That’s exactly what MCP Agent is built for.

This blog is for anyone who's been curious about agents and wants to build one—starting from scratch. We'll walk you through the basics using the open-source MCP Agent framework and help you build an agent that uses LLMs to reason and act across multiple tools.

If you're new to the Model Context Protocol (MCP), no worries. We’ll start simple and explain what matters as we go.

🌐 What is MCP?

The Model Context Protocol (MCP) is an open standard for connecting LLMs to real tools in a structured, consistent way.

It helps you:

Automate real-world tasks using LLMs
Connect to tools like GitHub, Supabase, Slack, or your filesystem
Build workflows that span across multiple services

Think of it as Zapier, but for AI agents — with native support for LLMs and tool calling.

🧰 Why MCP Agent?

MCP Agent is an open-source Python SDK for building apps and agents on top of MCP.

With it, you can:

Build agents that go beyond chat
Compose and control complex workflows
Deploy agents locally or as production-ready APIs

Here's the block diagram of how the app would run:

⚙️ Install and Clone

# Option 1 (Recommended)
uv init
uv add mcp-agent

# Option 2
pip install mcp-agent

# Clone the examples repo
git clone https://github.com/lastmile-ai/mcp-agent.git
cd mcp-agent/examples

🛠️ Tutorial: Build a Simple App

We’ll start by calling the filesystem server to write a local file.

📁 Project structure:

simple_app/
├── main.py
├── mcp_agent.config.yaml
├── mcp_agent.secrets.yaml
└── pyproject.toml

🧾 `mcp_agent.config.yaml`

mcp:
  servers:
    filesystem:
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-filesystem", "YOUR_PATH_HERE"]

🔐 `mcp_agent.secrets.yaml`

secrets:
  filesystem:
    root_path: "YOUR_PATH_HERE"

Replace YOUR_PATH_HERE with your actual project directory.

📦 `pyproject.toml`

[project]
name = "simple-app"
version = "0.1.0"
dependencies = ["mcp-agent>=0.0.20"]

Install dependencies:

pip install -e .

🧪 Example: Adding Intelligence with a Simple Agent

Here’s a simplified example of building an intelligent agent that can browse and write files.

import asyncio
from mcp_agent.app import MCPApp
from mcp_agent.agents.agent import Agent
from mcp_agent.mcp.mcp_connection_manager import MCPConnectionManager
from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
from mcp_agent.workflows.llm.augmented_llm import RequestParams

app = MCPApp(name="simple_agent")

async def run_agent():
    async with app.run() as agent_app:
        context = agent_app.context
        logger = agent_app.logger

        async with MCPConnectionManager(context.server_registry):
            agent = Agent(
                name="simple_agent",
                instruction="""You are a smart agent that opens a browser and saves results to a file.""",
                server_names=["playwright", "filesystem"]
            )

            llm = await agent.attach_llm(OpenAIAugmentedLLM)
            request_params = RequestParams(model="gpt-4o")

            prompt = """1. Use Playwright to open a site.
2. Extract page title.
3. Save title to a file using Filesystem server."""

            result = await llm.generate_str(prompt, request_params=request_params)
            print("✅ Result:", result)
            await agent.close()

if __name__ == "__main__":
    asyncio.run(run_agent())

💡 This template can be extended to coordinate multiple tools, add prompt customization, and integrate workflows like scraping, data cleaning, and automated reporting.

▶️ Run Your App

python main.py

You should see output.txt created in your project directory.

🧯 Common Issues

Problem	Fix
Server not found	Check the spelling in `config.yaml`
Permission errors	Double-check your root path
Timeout	Make sure Node.js is installed
Tool not available	Confirm the tool exists on the server

👥 Join the Community

⭐ GitHub: lastmile-ai/mcp-agent
💬 Discord: Join us

Let us know what you build. We’re excited to see where you take it!

Built a stock analyzer using MCP Agents.

Hanieh Zahiremami — Fri, 23 May 2025 15:21:34 +0000

I built a financial analyzer agent with MCP Agent that pulls stock-related data from the web, verifies the quality of the information, analyzes it, and generates a structured markdown report. (My partner needed one, so I built it to help him make better decisions lol.) It’s fully automated and runs locally using MCP servers for fetching data, evaluating quality, and writing output to disk.

At first, the results weren’t great. The data was inconsistent, and the reports felt shallow. So I added an EvaluatorOptimizer, a function that loops between the research agent and an evaluator until the output hits a high-quality threshold. That one change made a huge difference.

In my opinion, the real strength of this setup is the orchestrator. It controls the entire flow: when to fetch more data, when to re-run evaluations, and how to pass clean input to the analysis and reporting agents. Without it, coordinating everything would’ve been a mess. Also, it’s always fun watching the logs and seeing how the LLM thinks!

Take a look and let me know what you think.

🤖 5 AI Apps You Can Start Building Using MCP Agents

Hanieh Zahiremami — Mon, 07 Apr 2025 20:50:45 +0000

(From someone building with mcp_agent and friends)

Hey Devs 👋

I've been deep in the world of Model Context Protocol (MCP) lately — experimenting, hacking, and exploring what happens when you stop building chatbots... and start building actual agents.

MCP is one of the most exciting things to emerge in AI infra recently — a clean, open protocol for letting language models interact with tools, data, and environments in a standardized way. It gives you a structure to move beyond one-off API calls and finally treat agents like autonomous reasoning systems with access to real-world context.

And here’s the best part: there’s already a growing ecosystem of MCP-based agent apps you can fork, extend, or build on top of today.

The folks at LastMile AI have been doing amazing work open-sourcing examples like mcp_agent_server, mcp_basic_agent, and more. I’ve been experimenting with them myself, and wanted to share 5 apps you can start building on top of right now 👇

1. 🗂️ File + URL Finder Agent

Repo: mcp_basic_agent by LastMile AI

A smart “Finder” agent that decides whether to fetch data from a URL or read from your local filesystem. It uses the MCP fetch and filesystem servers and lets the LLM decide what to use based on the request.

💡 Ideas to build on top:

Add PDF, CSV, or Markdown parsing with semantic search
Improve retrieval ranking or stream long content
Combine local docs with live web data for richer context

Use case: Your own personal research assistant that knows where to look.

2. 🧠 Bedrock-Powered Web Intelligence Agent

Repo: mcp_basic_bedrock_agent

This example swaps in AWS Bedrock as the LLM engine, and uses the same MCP fetch server to retrieve content from URLs. Simple, powerful, and easy to plug into a cloud-native workflow.

💡 Ideas to build on top:

Add summarization + classification in a single agent loop
Integrate Bedrock toolchains (e.g. Titan, Cohere, etc.)
Customize model selection based on task type

Use case: A compliant, scalable research bot for enterprise teams.

3. 💬 Slack Workflow Agent

Repo: mcp_basic_slack_agent

This agent can read and write to Slack and your local filesystem — meaning it can do things like read a file and send it to a Slack channel, or archive Slack messages to disk.

💡 Ideas to build on top:

Add Slack thread summarization or channel digests
Create alerts triggered by file system events
Build a Slack → Notion or Slack → CRM handoff tool

Use case: Build lightweight internal tools without writing frontend code.

4. 🔄 GitHub-to-Slack Agent

Repo: mcp_github_to_slack_agent

A full-on dev tool: this agent monitors GitHub pull requests, analyzes them using an LLM, and posts ranked, readable summaries directly into Slack. It helps teams focus on high-priority changes without drowning in GitHub noise.

💡 Ideas to build on top:

Add issue tracking, test coverage, or CI context
Flag risky PRs with large diffs or missing reviewers
Extend to post weekly digests across multiple repos

Use case: A dev productivity bot that does the reading for you.

5. 🎛️ Model Selector Agent

Repo: mcp_model_selector

This one uses MCP’s ModelPreferences to let an agent dynamically choose which LLM to use — based on priorities like speed, cost, and performance.

💡 Ideas to build on top:

Build a smart router that uses different models mid-task
Add tracking for token usage or hallucination risk
Create a GUI dashboard to compare runs by model

Use case: A foundation for model-routing infrastructure for cost-aware AI apps.

👀 Why This Is Worth Building On

All of these examples were built by the team at LastMile AI to showcase what MCP agents are capable of. They’re open source, composable, and ready to be remixed.

Each app is:

Built on top of mcp_agent_server
Structured using clean context schemas and tool interfaces
Designed to show practical, real-world AI agent workflows

And contributions are welcome💥

🧠 If You’re Curious About Agents...

This is an awesome time to dive in. The protocol is still young, but the ideas are rock solid. Whether you're building a side project or integrating AI into real workflows, MCP gives you a clear foundation for context-aware, tool-using, and outcome-oriented AI.

If you’ve got ideas, questions, or want to collab — feel free to ping me.

And if you build something cool, definitely tag the LastMile team or contribute back.

Let’s go from LLMs to agents — for real.