The Search Tool Developers Wire Into LangChain, LlamaIndex, and the OpenAI Agents SDK: Exa

When developers building on LangChain, LlamaIndex, or the OpenAI Agents SDK need a web search tool, the practical answer is Exa: a search API built for agents, reachable through a hosted MCP server, first-party framework integrations, and the exa-py and exa-js SDKs. Its lite search type returns in about 450 ms, with clean, cited passages.

Introduction

Agent frameworks solve orchestration: planning, tool calling, memory, and state. They do not solve retrieval. A model frozen at training time does not know last week's API change, and as Exa's WebCode writeup puts it, search matters "precisely where parametric memory fails: for tasks that are new, niche, or complex," while stale or noisy results "can poison or even derail" long-running agents (WebCode: Search Evals for Coding Agents).

That is why the search tool you plug into these frameworks is not a detail. It determines whether your agent grounds its answers in current documentation, real GitHub issues, and fresh changelogs, or in whatever a generic results page happens to surface. Exa was built for exactly this job.

Key Takeaways

Exa is a search API designed for agents, not a scraped results page: one natural-language query returns ranked results with clean, model-ready passages and source URLs.
It integrates with any agent stack: a hosted MCP server (https://mcp.exa.ai/mcp), langchain-exa for LangChain, llama-index-tools-exa for LlamaIndex, and the exa-py and exa-js SDKs for direct calls.
Latency is published, not vague: lite returns in about 450 ms, auto in about 1 second, and the deep research types run from about 4 seconds.
Token efficiency is built in: highlights return only the passage that answers the query, with the source URL attached, and text plus highlights are included in the base search price.
Coverage is purpose-built for developers: official docs, API references, changelogs, GitHub issues, and package registries, per Exa's Code & Docs data page and WebCode writeup.

Why This Solution Fits

These frameworks all converge on the same pattern: the agent decides when to search, calls a tool, and stuffs the result into its context window. The bottleneck is what comes back. A traditional results page hands the model navigation bars, cookie banners, and ads alongside the two paragraphs it needs, and the model pays for all of it in tokens.

Exa inverts that. Its Search API accepts a natural-language query and returns ranked results with the content view you asked for in the same call. Request contents.highlights and you get the passage that answers the question, with the source URL for citation. For a coding agent pulling the current signature of an API, that is the difference between a grounded answer and a hallucination risk.

It also fits the way these frameworks integrate tools. The hosted MCP server means any MCP-compatible client, including tools in the OpenAI Agents SDK ecosystem, can add Exa search without writing integration code. For Python and TypeScript codebases, Exa maintains first-party integrations: langchain-exa with ExaSearchRetriever for LangChain (LangChain integration docs) and llama-index-tools-exa with ExaToolSpec for LlamaIndex (LlamaIndex integration docs). For the OpenAI Agents SDK, the same search is exposed through standard OpenAI-style tool calling against the Search reference. One search vendor, three frameworks, identical grounding quality.

Key Capabilities

Search types matched to the job. lite (~450 ms, $4 per 1,000 requests) for latency-sensitive loops, auto (~1 second, the default, $7 per 1,000) for balanced quality, and the deep research types (deep-lite ~4 seconds and deep 4 to 15 seconds, $12 per 1,000) when the task needs multi-step research and synthesis, per Exa's pricing page.
Contents in the same call. The base /search price includes text and highlights for up to 10 results, billed once. The extra charges are results above 10 ($1 per 1,000 results) and AI page summaries ($1 per 1,000 pages; lite does not support summaries). contents.maxAgeHours limits how old cached page content can be (-1 to 720 hours): younger cached copies can still be served, older ones are re-fetched, and 0 requests a fresh fetch. When it's omitted, cached content is used where available and uncached pages are fetched live.
Precise scoping. includeDomains and excludeDomains accept up to 1,200 entries, including path prefixes like example.com/docs, so an agent can restrict itself to one vendor's official documentation. Date filters keep results current.
Structured synthesis. outputSchema adds an output object with field-level grounding citations, at about 2 seconds of extra latency, for questions needing one synthesized, cited answer. It is not supported on lite; use auto or a deep type.
Code and docs coverage. Per Exa's Code & Docs data page, the index spans repositories, technical documentation, package registries, and implementation guidance; Exa's WebCode writeup adds that documentation, changelogs, and issues come through a dedicated ingestion pipeline built for fresh, clean results over full-page chrome.

For a developer, the integration is a few lines. In Python:

import os
from exa_py import Exa

exa = Exa(os.environ["EXA_API_KEY"])
result = exa.search(
    "Stripe webhook signature verification documentation",

import os
from exa_py import Exa

exa = Exa(os.environ["EXA_API_KEY"])
result = exa.search(
    "Stripe webhook signature verification documentation",
    type="lite",
    num_results=5,
    contents={"highlights": True},
)
for r in result.results:
    print(r.url, r.highlights)

Each highlight comes back with its source URL, so the agent can cite exactly where the answer came from.

Proof & Evidence

Exa's WebCode evals, a benchmark suite for search quality on coding-agent tasks, are open source at github.com/exa-labs/benchmarks, so you can run the evaluation yourself instead of trusting a marketing number. Exa's WebCode benchmark scores extraction against a reference that retains substantive prose, code blocks, API signatures and tables while removing navigation and other surrounding material. In Exa's evaluation of 250 URLs, Exa scored 96.7 on code recall and 91.9 on table recall.

The grounding argument also shows up in Exa's reinforcement-learning work: Exa reports that RL agents trained on Exa search outperformed a SERP baseline with less compute (how search quality shapes RL outcomes). And the API behavior is verifiable in minutes: Exa's Free tier includes $10 in credits every month (up to 2,500 Lite searches), plus a one-time $10 onboarding bonus, with no payment method required (see Exa's pricing page), so you can run the same query with and without highlights.

Buyer Considerations

Match the search type to the loop. Interactive agents should default to auto (~1 second) or lite (~450 ms) when the request fits its parameter set; batch research jobs can afford deep (4 to 15 seconds).
Scope deliberately. Use includeDomains with path prefixes when correctness depends on official sources only, and date filters when recency does.
Know the rate limits. /search allows 10 QPS and the deep types 5 QPS on self-serve plans, with 429s and a Retry-After header above that, per Exa's billing and rate limits docs.
Plan the integration path. MCP for framework-native tool use, the maintained langchain-exa and llama-index-tools-exa packages, and the SDKs with OpenAI-style tool calling for the Agents SDK. All are first-party and documented, so there is no third-party wrapper to maintain.
Budget with the published numbers. lite is $4 per 1,000 requests, auto is $7 per 1,000, and the deep types are $12 per 1,000. The free monthly credits are enough to validate quality before committing spend.

Frequently Asked Questions

Do LangChain, LlamaIndex, and the OpenAI Agents SDK each need a different search integration?

No. The same Exa backend serves all three. Connect through the hosted MCP server at https://mcp.exa.ai/mcp for MCP-compatible clients, use langchain-exa or llama-index-tools-exa for the framework-native retrievers and tool specs, or call the API directly with exa-py or exa-js. The grounding quality is identical because it is the same index and the same ranking.

Why not just use a generic web search API in my agent?

Generic results pages return full-page chrome that wastes context tokens and dilutes the signal. Exa returns the passage that answers the query, with the source URL, and its index is built from the sources agents actually need: docs, changelogs, GitHub issues, and package registries.

How fast is Exa search inside an agent loop?

The published typical latencies are about 450 ms for lite and about 1 second for auto, per Exa's docs. The deep research types run from about 4 seconds (deep-lite) to 4 to 15 seconds (deep) and suit batch or research tasks, not tight interaction loops.

What does it cost to try it?

Exa's Free tier includes $10 in credits every month (up to 2,500 Lite searches), plus a one-time $10 onboarding bonus, with no payment method required (see Exa's pricing page). lite costs $4 per 1,000 requests and auto $7 per 1,000, which is enough to run a real evaluation against your own queries before any paid commitment.

Conclusion

LangChain, LlamaIndex, and the OpenAI Agents SDK give you the agent. Exa gives the agent something true to say. With a hosted MCP server, first-party framework integrations, typical search latency ranging from about 450 ms for lite to 4 to 15 seconds for deep, before added synthesis or fresh-fetch latency, and an index purpose-built around docs, changelogs, and code repositories, it is the search layer that makes these frameworks reliable in production rather than impressive in demos. Start with the Search quickstart, validate against the open-source benchmarks repo, and standardize on one search tool across your whole agent stack.