Use remote MCP servers in the OpenAI API and Agents SDK

pip install --upgrade openai           # Python
npm install openai                     # TypeScript
export OPENAI_API_KEY=sk-...

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
        }
    ],
    input="Roll 2d4+1",
)
print(resp.output_text)

import OpenAI from "openai";

const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
    },
  ],
  input: "Roll 2d4+1",
});
console.log(resp.output_text);

for item in resp.output:
    if item.type == "mcp_call":
        print(item.name, item.arguments, "->", item.output, item.error)

tool = {
    "type": "mcp",
    "server_label": "deepwiki",
    "server_url": "https://mcp.deepwiki.com/mcp",
    "allowed_tools": ["ask_question", "read_wiki_structure"],
    "require_approval": "never",
}

tool = {
    "type": "mcp",
    "server_label": "dmcp",
    "server_url": "https://dmcp-server.deno.dev/mcp",
    "require_approval": "always",
}

resp = client.responses.create(model="gpt-6-astra", tools=[tool], input="Roll 2d4+1")

approvals = []
for item in resp.output:
    if item.type == "mcp_approval_request":
        print(f"{item.server_label}.{item.name} wants: {item.arguments}")
        approvals.append({
            "type": "mcp_approval_response",
            "approve": True,  # decide per call in real code
            "approval_request_id": item.id,
        })

if approvals:
    resp = client.responses.create(
        model="gpt-6-astra",
        tools=[tool],
        previous_response_id=resp.id,
        input=approvals,
    )
print(resp.output_text)

const tool = {
  type: "mcp" as const,
  server_label: "dmcp",
  server_url: "https://dmcp-server.deno.dev/mcp",
  require_approval: "always" as const,
};

let resp = await client.responses.create({ model: "gpt-6-astra", tools: [tool], input: "Roll 2d4+1" });

const approvals = resp.output.flatMap((item) =>
  item.type === "mcp_approval_request"
    ? [{
        type: "mcp_approval_response" as const,
        approve: true, // decide per call in real code
        approval_request_id: item.id,
      }]
    : []
);

if (approvals.length > 0) {
  resp = await client.responses.create({
    model: "gpt-6-astra",
    tools: [tool],
    previous_response_id: resp.id,
    input: approvals,
  });
}
console.log(resp.output_text);

"require_approval": {"never": {"tool_names": ["ask_question", "read_wiki_structure"]}}

import os

resp = client.responses.create(
    model="gpt-6-astra",
    input="Create a payment link for $20",
    tools=[
        {
            "type": "mcp",
            "server_label": "stripe",
            "server_url": "https://mcp.stripe.com",
            "authorization": os.environ["STRIPE_OAUTH_ACCESS_TOKEN"],
        }
    ],
)

import asyncio
from agents import Agent, HostedMCPTool, Runner

agent = Agent(
    name="Repo expert",
    instructions="Answer questions about GitHub repositories using DeepWiki.",
    model="gpt-6-astra",
    tools=[
        HostedMCPTool(
            tool_config={
                "type": "mcp",
                "server_label": "deepwiki",
                "server_url": "https://mcp.deepwiki.com/mcp",
                "allowed_tools": ["ask_question"],
                "require_approval": "never",
            }
        )
    ],
)

async def main():
    result = await Runner.run(agent, "How does routing work in vercel/next.js?")
    print(result.final_output)

asyncio.run(main())

import { Agent, hostedMcpTool, run } from "@openai/agents";

const agent = new Agent({
  name: "Repo expert",
  instructions: "Answer questions about GitHub repositories using DeepWiki.",
  model: "gpt-6-astra",
  tools: [
    hostedMcpTool({
      serverLabel: "deepwiki",
      serverUrl: "https://mcp.deepwiki.com/mcp",
      allowedTools: ["ask_question"],
      requireApproval: "never",
    }),
  ],
});

const result = await run(agent, "How does routing work in vercel/next.js?");
console.log(result.finalOutput);

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(
        name="dice",
        params={"url": "http://localhost:8787/mcp"},
    ) as server:
        agent = Agent(name="Dice", instructions="Use the tools to roll dice.",
                      model="gpt-6-astra", mcp_servers=[server])
        result = await Runner.run(agent, "Roll 3d6")
        print(result.final_output)

asyncio.run(main())

import { Agent, MCPServerStreamableHttp, run } from "@openai/agents";

const server = new MCPServerStreamableHttp({ url: "http://localhost:8787/mcp", name: "dice" });
await server.connect();
try {
  const agent = new Agent({ name: "Dice", instructions: "Use the tools to roll dice.",
                            model: "gpt-6-astra", mcpServers: [server] });
  const result = await run(agent, "Roll 3d6");
  console.log(result.finalOutput);
} finally {
  await server.close();
}