MCP Research Agent — Schema-Based Web Data for AI Agents

Give AI agents (Claude, ChatGPT, custom LLMs) schema-based, structured web data: send a research question + the fields you want (a schema) → the actor searches the web, fetches pages, and structures them into your requested JSON schema → it returns clean, predictable JSON.

No subscription — pay per event. You pay per run + per search + per page structured. Nothing else.

---

What it does

LLM agents don't want web data as a raw markdown blob — they want it in a shape they can consume directly. This actor combines "search → fetch → fit to schema" into a single tool. The agent only says what it wants (the fields); the output comes back in the same shape every time.

• 🔎 Searches the web for your question (via an upstream search actor).
• 📄 Fetches the result pages.
• 🧩 Structures each page into exactly your JSON schema — missing fields become null, types are coerced ("19,999.90 TL" → 19999.9).
• 🛡️ Per-field confidence: every field gets a deterministic confidence label so the agent knows what it can trust.

Input

Field	Description
query	The research question (required).
schema	The fields to extract (required). ["name","price"] or [{"name":"price","type":"number"}]. Types: string | number | boolean | array | object.
maxResults	Max number of sources to structure (1-50, cost control).
language	Output language of the natural-language text values (JSON keys stay unchanged).
model	(Advanced) LLM model — the default is cheap and fast.

Output (dataset)

{
  "query": "...",
  "schema": ["name", "price", "in_stock"],
  "result_count": 5,
  "results": [
    {
      "name": "...",
      "price": 19999.9,
      "in_stock": true,
      "_source_url": "...",
      "_confidence": {"name": "high", "price": "high", "in_stock": "grounded"}
    }
  ],
  "sources": [{"title": "...", "url": "..."}]
}

Missing fields come back as null — the schema integrity is always preserved (the agent parses safely). Values are coerced to the schema type.

Each record carries two meta fields:

• _source_url — the source page the value was extracted from.

• _confidence — a deterministic confidence label per field. All types go through real grounding (boolean/array included — there is no blind "filled" flag):

  • high — a string/number value was found verbatim in the source (digit-aware matching for numbers).
  • grounded — a boolean/array value is supported by evidence in the source (e.g. for in_stock=true the source contains "in stock"; at least one list element appears in the source). Word-boundary-aware matching reduces false positives.
  • unverified — the field is filled but unsupported in the source (may be an LLM inference — the agent should verify). object fields cannot be verified deterministically, so they honestly return unverified.
  • null — the field is empty.

  Important: high/grounded means "verified in the fetched source text" — not "absolutely true on the internet". For critical decisions, the agent should verify unverified fields itself.

Honest boundary

This actor is a research + structuring layer, not a ground-truth database. Output quality depends directly on the quality of the fetched web sources: the web search is delegated to an upstream search actor (e.g. apify/rag-web-browser), and the actor structures only that fetched text to the schema, putting null where the source has no information (no fabrication). If the source is weak/incomplete, fields come back unverified or null — that is an honest signal, not a defect.

Using it as an MCP server

This actor runs both ways:

1. As a classic Apify Actor — call it directly (query → structured JSON), via the Apify Console, API, or schedule.
2. As an MCP-server tool — Apify exposes the actor over its hosted MCP endpoint (https://mcp.apify.com). An MCP-compatible AI agent (e.g. Claude Desktop, or any client implementing the Model Context Protocol) connects to that endpoint and calls this actor as a structured_web_research-style tool: the agent passes query + schema, the actor runs, and the structured JSON is returned to the agent as the tool result.

The actor logic is identical in both modes — same input, same output, same Pay-Per-Event billing (the agent pays per call). To use it from an MCP client, add the Apify hosted MCP server to your client's MCP configuration and reference this actor; consult the Apify MCP documentation for the exact connection/auth setup.

Why this actor?

Almost every MCP tool is free; paid, value-adding MCP tools are rare. "Search → fetch → fit to schema" in a single tool, with predictable output — a structure agents can connect to with confidence.

Pricing (Pay-Per-Event)

You only pay for what you use: per run + per search + per page structured. No monthly subscription.