Skip to main content

ChatGPT Deep Research & MCP Servers

· 8 min read
Tony Lewis
MCPBundles

OpenAI just made it clear: if you want your MCP server to work with ChatGPT's deep research capabilities, it needs to implement two specific tools: search and fetch.

This isn't optional. It's the protocol standard that enables ChatGPT to discover and retrieve information from external data sources. And if you're using MCPBundles, you already have it.

What is ChatGPT Deep Research?​

ChatGPT's deep research mode is a specialized capability that goes beyond simple chat interactions. When you enable deep research:

  • ChatGPT systematically explores multiple data sources
  • It conducts iterative searches to find relevant information
  • It fetches full documents to synthesize comprehensive answers
  • It cites sources and builds structured research outputs

Think of it as having a research assistant that can query your private databases, documentation, CRM systems, and knowledge bases—all through MCP connectors.

The Search & Fetch Standard​

OpenAI defined a specific contract for MCP servers that want to participate in deep research. Your server must implement exactly two tools with specific schemas.

The search Tool​

Purpose: Return a list of relevant results from your data source given a query.

Arguments:

  • A single query string

Returns:

  • An array of result objects, each containing:
    • id - unique identifier for the document
    • title - human-readable title
    • url - canonical URL for citation

Example response:

{
  "content": [
    {
      "type": "text",
      "text": "{\"results\":[{\"id\":\"doc-42\",\"title\":\"Q3 Sales Strategy\",\"url\":\"https://internal.company.com/docs/sales-q3\"}]}"
    }
  ]
}

When ChatGPT runs a deep research query, it starts with search. It might call your MCP server's search tool multiple times with different queries, refining its understanding as it goes.

The fetch Tool​

Purpose: Retrieve the full contents of a specific document.

Arguments:

  • A single id string (from a previous search result)

Returns:

  • A document object containing:
    • id - the document identifier
    • title - document title
    • text - the full text content
    • url - canonical URL for citation
    • metadata - optional key/value pairs about the document

Example response:

{
  "content": [
    {
      "type": "text",
      "text": "{\"id\":\"doc-42\",\"title\":\"Q3 Sales Strategy\",\"text\":\"Our Q3 strategy focuses on...\",\"url\":\"https://internal.company.com/docs/sales-q3\",\"metadata\":{\"author\":\"Jane Doe\",\"department\":\"Sales\"}}"
    }
  ]
}

After ChatGPT identifies relevant documents with search, it uses fetch to get the full content. This is where the real power comes in—ChatGPT can now read entire documents, synthesize information, and generate comprehensive research outputs.

Why This Matters for Your Workflow​

Let's look at a real scenario. You ask ChatGPT:

"Analyze our customer support trends from the last quarter and recommend improvements."

Without MCP connectors, ChatGPT has no access to your data. With a properly configured MCP server, here's what happens:

  1. ChatGPT calls search with query: "customer support trends Q2 2025"
  2. Your MCP server returns results from Zendesk, internal docs, and analytics
  3. ChatGPT evaluates relevance and calls fetch for the top 5 documents
  4. Your MCP server returns full content for each document
  5. ChatGPT synthesizes a comprehensive analysis with citations
  6. ChatGPT searches again with refined queries based on findings
  7. Process repeats until ChatGPT has complete context

This is iterative research powered by the search/fetch standard. It's how ChatGPT transforms from a chat interface into a research engine.

MCPBundles Implementation​

When we built MCPBundles, we knew this standard was coming. Here's how we implemented it:

Universal Search Across All Providers​

Every bundle in MCPBundles automatically exposes a search tool that queries across all providers in that bundle. If your bundle includes:

  • GitHub (search repositories, issues, PRs)
  • Confluence (search documentation)
  • Slack (search messages and files)
  • Salesforce (search CRM records)

A single search call queries all four simultaneously and returns unified results.

Smart Fetch with Provider Routing​

When ChatGPT calls fetch with a document ID, MCPBundles automatically routes to the correct provider and retrieves the full content. The ID format encodes the provider and resource type, so we know exactly where to get the data.

For example:

  • github:repo:my-org/my-repo → fetches repository README
  • confluence:page:123456 → fetches full page content
  • slack:message:C123456/p987654 → fetches message thread
  • salesforce:opportunity:006abc123 → fetches opportunity details

Authentication & Authorization Built In​

The hard part of MCP servers isn't implementing search and fetch—it's handling authentication. MCPBundles manages this for you:

  • OAuth flows for each provider
  • Token refresh automatically handled
  • Scope validation ensures proper access
  • User-scoped credentials (your credentials, your data)

When ChatGPT calls your bundle's search or fetch tools, MCPBundles injects the correct authenticated requests to each provider's API.

How to Use It with ChatGPT​

Via API (Responses API)​

If you're using ChatGPT via the OpenAI API with deep research:

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
  "model": "o4-mini-deep-research",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "What are the top customer pain points from our support tickets?"
        }
      ]
    }
  ],
  "tools": [
    {
      "type": "mcp",
      "server_label": "support-bundle",
      "server_url": "https://mcp.mcpbundles.com/bundle/customer-support",
      "allowed_tools": ["search", "fetch"],
      "require_approval": "never"
    }
  ]
}'

Via ChatGPT Desktop (Connectors)​

If you're using ChatGPT Desktop with connectors:

  1. Open ChatGPT Settings → Connectors
  2. Add your MCPBundles MCP URL: https://mcp.mcpbundles.com/bundle/[your-bundle-slug]
  3. Authenticate with your MCPBundles API key
  4. Enable "Deep Research" in the composer
  5. Start asking research questions

ChatGPT will automatically call your bundle's search and fetch tools as needed.

Why MCPBundles vs. Building Your Own​

You could build your own MCP server with search and fetch tools. But here's what you'd need to handle:

If You Build It Yourself:​

  • ✅ Implement search and fetch schemas correctly
  • ✅ Handle OAuth for every provider you integrate
  • ✅ Build token refresh logic
  • ✅ Create document ID encoding/routing
  • ✅ Deploy and maintain server infrastructure
  • ✅ Monitor performance and errors
  • ✅ Update when provider APIs change
  • ✅ Handle rate limiting and retries
  • ✅ Implement security and user scoping

With MCPBundles:​

  • ✅ Search and fetch already implemented
  • ✅ OAuth flows pre-configured for 50+ providers
  • ✅ Token management automatic
  • ✅ Provider routing handled
  • ✅ Cloud infrastructure managed
  • ✅ Monitoring and alerting included
  • ✅ Provider updates deployed automatically
  • ✅ Rate limiting and retries built in
  • ✅ User-scoped security enforced

You get deep research capabilities for ChatGPT without building or maintaining any infrastructure.

Real-World Use Cases​

Sales Research​

Query: "Find all opportunities closing this quarter with deal size > $100K"

ChatGPT searches Salesforce, HubSpot, and internal deal docs. Fetches full opportunity records. Synthesizes a ranked list with risk assessments.

Customer Success​

Query: "Which customers have submitted urgent tickets in the last 48 hours?"

ChatGPT searches Zendesk and Intercom. Fetches ticket details and customer profiles. Generates prioritized action list with context.

Engineering Research​

Query: "What are the open critical bugs related to authentication?"

ChatGPT searches GitHub issues, Jira, and PagerDuty incidents. Fetches issue descriptions and related PRs. Creates comprehensive bug report with impact analysis.

Content Research​

Query: "Summarize our Q2 product announcements for the quarterly board deck"

ChatGPT searches Confluence, Google Docs, and blog posts. Fetches full articles. Compiles executive summary with key metrics and links.

The Future of AI Research​

OpenAI's decision to standardize on search and fetch tools signals where the industry is heading. MCP is becoming the protocol for AI-native applications, and these two tools are the foundation.

When you implement search and fetch correctly:

  • Your MCP server works with ChatGPT deep research
  • It works with Claude's deep research mode (coming soon)
  • It works with any AI agent that follows the MCP standard
  • Your data becomes AI-accessible without custom integrations

This is the future of knowledge work: AI agents that can systematically explore your organization's data, fetch relevant content, and synthesize insights—all through a standardized protocol.

Getting Started​

Want to enable ChatGPT deep research with your data?

Step 1: Sign Up​

Create an account at mcpbundles.com/register

Step 2: Create a Bundle​

Choose the providers you want to integrate (Salesforce, GitHub, Slack, etc.)

Step 3: Connect Your Accounts​

Authenticate with each provider using our OAuth flows

Step 4: Get Your MCP URL​

Copy your bundle's MCP URL from the dashboard

Step 5: Configure ChatGPT​

Add the MCP URL to ChatGPT's connector settings

Step 6: Start Researching​

Enable deep research and ask ChatGPT to explore your data

For detailed setup instructions, check our ChatGPT Integration Guide.

The Bottom Line​

ChatGPT's deep research capability is powerful, but it needs MCP servers that implement search and fetch tools correctly.

MCPBundles implements these tools out of the box, with multi-provider search, smart document fetching, and automatic authentication handling. You get ChatGPT deep research capabilities across all your connected services without building or maintaining any infrastructure.

The protocol standard is here. The tools are ready. Now it's time to give ChatGPT access to your data.

Questions? Read our MCP documentation or check out the OpenAI MCP integration guide.