OpenAI Meets MCP: Transform Your AI Agents with Universal Tool Integration

Picture building an AI agent that needs to access your customer database, create support tickets, and calculate account values. Without a standard protocol, you’d write custom integration code for each tool—multiplied by every AI model you want to support. Enter the Model Context Protocol (MCP), which transforms this integration nightmare into a simple, reusable solution.

This article focuses on integrating MCP with OpenAI, showing you two powerful approaches: the streamlined Agents SDK and the flexible native API integration.

For a comprehensive overview of MCP and building servers with FastMCP, see our complete guide. To quickly grasp the custom MCP Server example that we are using for this article see **Building Your First FastMCP Server: A Complete Guide or the companion github repo.

Why OpenAI + MCP Changes Everything

OpenAI’s function calling capabilities are powerful, but they traditionally require custom integration code for each external tool. MCP standardizes this process, allowing you to:

• Write tool definitions once and use them across any MCP-compatible AI system
• Switch between AI providers without rewriting integration code
• Share tools with your team through a simple configuration file
• Build complex agent workflows with minimal boilerplate

Let’s explore two paths to MCP integration with OpenAI, each offering unique advantages.

About Our MCP Server: The Customer Service Assistant

Before we dive into connecting OpenAI and MCP, let’s examine what we’re working with. We’ve built a customer service MCP server using FastMCP (check out our complete guide if you’re curious). Consider it our sandbox for experimenting with different integration approaches.

Our server comes packed with three MCP tools that any AI can use:

Available MCP Tools:

• get_recent_customers: Enables access to customer activity records and status information, facilitating data-driven customer support decisions.
• create_support_ticket: Implements a structured ticket management system with priority assignment and built-in customer validation protocols.
• calculate_account_value: Provides comprehensive account analysis by evaluating transaction history and purchase metrics for customer service delivery.

What makes this special is that these tools work with any MCP-compatible client—whether you’re using OpenAI, Claude, LangChain, DSPy, or any other framework.

Path 1: The Express Lane with OpenAI Agents SDK

The OpenAI Agents SDK provides the fastest route to MCP integration. With just a few lines of code, you can create intelligent agents that use your MCP tools.

Setting Up Your First Agent

Here’s a complete example that creates a customer service agent with MCP tools:

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStdio
from config import Config

async def run_customer_service_scenarios():
    """Demonstrate OpenAI Agents + MCP integration."""
    print("🤖 Setting up OpenAI Agents + MCP integration...")

    # Create MCP server connection
    mcp_server = MCPServerStdio(
        params={
            "command": "poetry",
            "args": ["run", "python", "src/mcp_server_main.py"]
        },
        cache_tools_list=True,
        name="Customer Service Server",
        client_session_timeout_seconds=30
    )

    # Use the MCP server within an async context
    async with mcp_server as server:
        # Create agent with the connected MCP server
        agent = Agent(
            name="Customer Service Agent",
            instructions="""You are a helpful customer service assistant.
            Use the available tools to help customers with their requests.
            Always be professional and empathetic.""",
            mcp_servers=[server]
        )

        # Example customer service scenarios
        scenarios = [
            "Get a list of recent customers and summarize their status",
            "Create a high-priority support ticket for customer 67890",
            "Calculate the account value for customer 12345"
        ]

        for scenario in scenarios:
            result = await Runner.run(agent, scenario)
            print(f"🤖 Agent Response: {result.final_output}")

The beauty of this approach lies in its simplicity. The OpenAI Agents SDK handles all the complexity of:

• Discovering available tools from your MCP server
• Converting tool calls between OpenAI and MCP formats
• Managing the conversation flow
• Handling errors gracefully

Key Benefits of the Agents SDK Approach

1. Minimal Code: Just configure your MCP server and let the SDK handle the rest
2. Automatic Tool Discovery: No need to manually define tools—they’re loaded from your MCP server
3. Built-in Context Management: The SDK manages async contexts and cleanup automatically
4. Production-Ready: Includes error handling, retries, and timeout management

Path 2: Maximum Control with Native OpenAI API

For developers who need fine-grained control over the integration, the native OpenAI API approach offers complete flexibility while still benefiting from MCP standardization.

Building a Custom MCP Client

Here’s how to create a full-featured chatbot using OpenAI’s native API with MCP:

import asyncio
import json
from contextlib import AsyncExitStack
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import AsyncOpenAI

class OpenAIMCPChatBot:
    def __init__(self, api_key: str):
        self.client = AsyncOpenAI(api_key=api_key)
        self.sessions = []
        self.exit_stack = AsyncExitStack()
        self.available_tools = []
        self.tool_to_session = {}

    async def connect_to_server(self, server_name: str, server_config: dict):
        """Connect to a single MCP server."""
        server_params = StdioServerParameters(**server_config)
        stdio_transport = await self.exit_stack.enter_async_context(
            stdio_client(server_params)
        )
        read, write = stdio_transport
        session = await self.exit_stack.enter_async_context(
            ClientSession(read, write)
        )
        await session.initialize()

        # Discover and convert tools to OpenAI format
        response = await session.list_tools()
        for tool in response.tools:
            self.tool_to_session[tool.name] = session
            openai_tool = {
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.inputSchema,
                },
            }
            self.available_tools.append(openai_tool)

Processing Queries with Tool Execution

The native approach gives you complete control over the conversation flow:

async def process_query(self, query: str):
    """Process a query using OpenAI with MCP tools."""
    messages = [{"role": "user", "content": query}]

    response = await self.client.chat.completions.create(
        model="gpt-4",
        messages=messages,
        tools=self.available_tools
    )

    # Handle tool calls in a loop
    while response.choices[0].message.tool_calls:
        message = response.choices[0].message
        messages.append(message)

        # Execute each tool call through MCP
        for tool_call in message.tool_calls:
            session = self.tool_to_session[tool_call.function.name]
            result = await session.call_tool(
                tool_call.function.name,
                arguments=json.loads(tool_call.function.arguments)
            )

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(result.content)
            })

        # Get the final response with tool results
        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=messages,
            tools=self.available_tools
        )

Advantages of Native Integration

1. Complete Control: Manage every aspect of the conversation flow
2. Custom Logic: Add middleware, logging, or custom processing between steps
3. Multi-Server Support: Connect to multiple MCP servers simultaneously
4. Advanced Features: Implement streaming, conversation memory, or custom retry logic

Architecture: How It All Connects

Understanding the architecture helps you choose the right approach for your needs:

┌─────────────────┐     ┌─────────────────┐
│   Your Code     │     │   Your Code     │
│ (Agents SDK)    │     │ (Native API)    │
└────────┬────────┘     └────────┬────────┘
         │                       │
         ▼                       ▼
┌─────────────────┐     ┌─────────────────-┐
│ MCPServerStdio  │     │ MCP ClientSession│
│ (Built-in)      │     │ (Direct Control) │
└────────┬────────┘     └────────┬────────-┘
         │                       │
         └───────────┬───────────┘
                     ▼
          ┌─────────────────┐
          │   MCP Server    │
          │  (Your Tools)   │
          └─────────────────┘

Both approaches communicate with the same MCP server, but offer different levels of abstraction and control.

Real-World Example: Customer Service Bot

Let’s see both approaches in action with a practical example. Imagine a customer service bot that needs to:

1. Look up customer information
2. Create support tickets
3. Calculate account values

Using the Agents SDK

# Simple and declarative
agent = Agent(
    name="Support Bot",
    instructions="Help customers with their inquiries",
    mcp_servers=[mcp_server]
)

result = await Runner.run(agent,
    "Customer 12345 says their product is defective. Help them.")

# The agent automatically:

# - Looks up the customer

# - Creates a support ticket

# - Provides a helpful response

Using Native API

# Full control over each step
chatbot = OpenAIMCPChatBot(api_key)
await chatbot.connect_to_servers()


# You can add custom logic between steps
await chatbot.process_query(
    "Customer 12345 says their product is defective.")

# You control:

# - How tools are called

# - Error handling

# - Response formatting

# - Conversation memory

Getting Started: Your Next Steps

1. Clone the example repository: Get working code for both approaches

   git clone https://github.com/RichardHightower/mcp_article1
   cd mcp_article1
   

2. Choose your path:

   • For rapid prototyping: Start with the Agents SDK
   • For production systems with specific requirements: Use native API

3. Build your MCP server: Follow our comprehensive guide to create custom tools or to ramp up faster see Building Your First FastMCP Server: A Complete Guide

4. Connect and iterate: Both approaches support hot-reloading, so you can develop tools without restarting your client

Key Takeaways

The Model Context Protocol transforms OpenAI from a text-generation engine into a powerful platform for building intelligent, tool-enabled applications. Whether you choose the simplicity of the Agents SDK or the flexibility of native API integration, MCP ensures your tools remain portable and reusable.

By separating tool implementation from AI integration, MCP creates a future where:

• Tools built once work everywhere
• Switching AI providers requires changing only configuration
• Teams can share and compose tools effortlessly
• Complex agent workflows become manageable

The integration examples shown here are just the beginning. As you build more sophisticated tools and agents, MCP’s benefits compound, turning what would be a maintenance nightmare into a scalable, elegant solution.

Ready to transform your AI applications? Start with the example code, build your first MCP-enabled agent, and join the growing community of developers building the future of AI integration.

For a deep dive into MCP architecture, FastMCP server development, and integration with other frameworks like LangChain and DSPy, check out our comprehensive MCP guide. You can find the source code for the above code at this github repo.

About the Author

Rick Hightower brings extensive enterprise experience as a former executive and distinguished engineer at a Fortune 100 company, where he specialized in delivering Machine Learning and AI solutions to deliver intelligent customer experience. His expertise spans both the theoretical foundations and practical applications of AI technologies.

As a TensorFlow certified professional and graduate of Stanford University’s comprehensive Machine Learning Specialization, Rick combines academic rigor with real-world implementation experience. His training includes mastery of supervised learning techniques, neural networks, and advanced AI concepts, which he has successfully applied to enterprise-scale solutions.

With a deep understanding of both the business and technical aspects of AI implementation, Rick bridges the gap between theoretical machine learning concepts and practical business applications, helping organizations use AI to create tangible value.

If you like this article, follow Rick on LinkedIn or on Medium.