┌──────────────┐     ┌─────────────────┐     ┌──────────────┐
│   OpenAI     │ --> │   MCP-OpenAI    │ --> │  MCP Server  │
│   API/Chat   │ <-- │   Bridge        │ <-- │  (Your Tools)│
└──────────────┘     └─────────────────┘     └──────────────┘

mkdir mcp-openai-bridge
cd mcp-openai-bridge
npm init -y
npm install @modelcontextprotocol/sdk openai zod
npm install -D typescript @types/node
npx tsc --init

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
import OpenAI from 'openai';

class MCPOpenAIBridge {
  private mcpClient: Client;
  private openai: OpenAI;
  private tools: OpenAI.ChatCompletionTool[] = [];

  constructor() {
    this.mcpClient = new Client({
      name: 'openai-bridge',
      version: '1.0.0',
    });
    this.openai = new OpenAI();
  }

  async connectToMCPServer(command: string, args: string[]) {
    const transport = new StdioClientTransport({ command, args });
    await this.mcpClient.connect(transport);

    // Discover MCP tools and convert to OpenAI format
    const mcpTools = await this.mcpClient.listTools();
    this.tools = mcpTools.tools.map((tool) => ({
      type: 'function' as const,
      function: {
        name: tool.name,
        description: tool.description || '',
        parameters: tool.inputSchema as Record<string, unknown>,
      },
    }));

    console.log(`Connected. Found ${this.tools.length} tools.`);
  }

  async chat(userMessage: string): Promise<string> {
    const messages: OpenAI.ChatCompletionMessageParam[] = [
      { role: 'user', content: userMessage },
    ];

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages,
      tools: this.tools,
    });

    const choice = response.choices[0];
    if (choice.finish_reason === 'tool_calls' && choice.message.tool_calls) {
      // Execute MCP tools for each function call
      messages.push(choice.message);

      for (const toolCall of choice.message.tool_calls) {
        const result = await this.mcpClient.callTool(
          toolCall.function.name,
          JSON.parse(toolCall.function.arguments)
        );

        const textContent = result.content
          .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
          .map((c) => c.text)
          .join('\n');

        messages.push({
          role: 'tool',
          tool_call_id: toolCall.id,
          content: textContent,
        });
      }

      // Get final response with tool results
      const finalResponse = await this.openai.chat.completions.create({
        model: 'gpt-4',
        messages,
      });

      return finalResponse.choices[0].message.content || '';
    }

    return choice.message.content || '';
  }

  async disconnect() {
    await this.mcpClient.close();
  }
}

async function main() {
  const bridge = new MCPOpenAIBridge();

  // Connect to your MCP server
  await bridge.connectToMCPServer('node', ['./my-mcp-server.js']);

  // Chat using OpenAI with MCP tools
  const response = await bridge.chat('List the files in my workspace');
  console.log('Response:', response);

  await bridge.disconnect();
}

main().catch(console.error);

pip install mcp openai

import asyncio
import json
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from openai import OpenAI

class MCPOpenAIBridge:
    def __init__(self):
        self.openai = OpenAI()
        self.session = None
        self.tools = []

    async def connect(self, command: str, args: list[str]):
        server_params = StdioServerParameters(
            command=command,
            args=args,
        )
        self._stdio = stdio_client(server_params)
        self._read, self._write = await self._stdio.__aenter__()
        self.session = ClientSession(self._read, self._write)
        await self.session.__aenter__()
        await self.session.initialize()

        # Convert MCP tools to OpenAI format
        mcp_tools = await self.session.list_tools()
        self.tools = [
            {
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description or "",
                    "parameters": tool.inputSchema,
                },
            }
            for tool in mcp_tools.tools
        ]
        print(f"Connected. Found {len(self.tools)} tools.")

    async def chat(self, user_message: str) -> str:
        messages = [{"role": "user", "content": user_message}]

        response = self.openai.chat.completions.create(
            model="gpt-4",
            messages=messages,
            tools=self.tools if self.tools else None,
        )

        choice = response.choices[0]
        if choice.finish_reason == "tool_calls" and choice.message.tool_calls:
            messages.append(choice.message)

            for tool_call in choice.message.tool_calls:
                args = json.loads(tool_call.function.arguments)
                result = await self.session.call_tool(
                    tool_call.function.name, arguments=args
                )

                text_content = "\n".join(
                    c.text for c in result.content if c.type == "text"
                )
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": text_content,
                })

            final_response = self.openai.chat.completions.create(
                model="gpt-4",
                messages=messages,
            )
            return final_response.choices[0].message.content or ""

        return choice.message.content or ""

    async def disconnect(self):
        if self.session:
            await self.session.__aexit__(None, None, None)
        await self._stdio.__aexit__(None, None, None)

async def main():
    bridge = MCPOpenAIBridge()
    await bridge.connect("python", ["my_mcp_server.py"])

    response = await bridge.chat("What tools do you have available?")
    print("Response:", response)

    await bridge.disconnect()

asyncio.run(main())

import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const transport = new StreamableHTTPClientTransport(
  new URL('https://your-mcp-server.example.com/mcp')
);
await bridge.mcpClient.connect(transport);

class ConversationalBridge extends MCPOpenAIBridge {
  private conversationHistory: OpenAI.ChatCompletionMessageParam[] = [];

  async chat(userMessage: string): Promise<string> {
    this.conversationHistory.push({ role: 'user', content: userMessage });

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'system',
          content: 'You have access to MCP tools. Use them when appropriate.',
        },
        ...this.conversationHistory,
      ],
      tools: this.tools,
    });

    const choice = response.choices[0];

    if (choice.finish_reason === 'tool_calls' && choice.message.tool_calls) {
      this.conversationHistory.push(choice.message);

      for (const toolCall of choice.message.tool_calls) {
        const result = await this.mcpClient.callTool(
          toolCall.function.name,
          JSON.parse(toolCall.function.arguments)
        );

        const textContent = result.content
          .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
          .map((c) => c.text)
          .join('\n');

        this.conversationHistory.push({
          role: 'tool',
          tool_call_id: toolCall.id,
          content: textContent,
        });
      }

      const finalResponse = await this.openai.chat.completions.create({
        model: 'gpt-4',
        messages: [
          { role: 'system', content: 'You have access to MCP tools.' },
          ...this.conversationHistory,
        ],
      });

      const reply = finalResponse.choices[0].message.content || '';
      this.conversationHistory.push({ role: 'assistant', content: reply });
      return reply;
    }

    const reply = choice.message.content || '';
    this.conversationHistory.push({ role: 'assistant', content: reply });
    return reply;
  }

  clearHistory() {
    this.conversationHistory = [];
  }
}

async function safeMCPCall(
  client: Client,
  toolName: string,
  args: Record<string, unknown>
): Promise<string> {
  try {
    const result = await client.callTool(toolName, args);

    if (result.isError) {
      return JSON.stringify({ error: 'MCP tool returned an error', details: result.content });
    }

    return result.content
      .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
      .map((c) => c.text)
      .join('\n');
  } catch (error) {
    return JSON.stringify({
      error: 'Failed to call MCP tool',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
}