Pi Agent Search Provider Routing (2026)

A thread on r/PiCodingAgent asked which web search tools work with Pi. The answers split into four categories: Tavily (simple integration, paid), SearxNG (self-hosted, free but maintenance-heavy), custom MCP servers, and managed APIs like Scavio. Each has trade-offs. The most resilient pattern: multi-provider routing with fallback.

Option 1: Tavily

Tavily is the most common recommendation because it is the default in many LangChain examples. Setup is a single API key. The response includes a pre-summarized answer field optimized for feeding into LLMs. Cost: 1K free credits per month, then $0.008/credit on PAYG. Since the Nebius acquisition, Tavily's roadmap is tied to Nebius's inference cloud strategy, which may or may not matter for your use case.

Option 2: SearxNG (self-hosted)

SearxNG is free and open-source, aggregating results from multiple search engines. The trade-off: you host it yourself. That means a VPS ($5-10/mo), Docker setup, and ongoing maintenance when upstream search engines change their response format. For a coding agent that needs reliable search, SearxNG uptime depends on your ops discipline.

Option 3: Custom MCP server

Build an MCP server that wraps any search API. This gives the agent typed tool definitions and lets you swap providers without changing the agent configuration. After adding the MCP server to your config, run /reload in your agent environment to pick up the new tools.

Option 4: Managed API (Scavio)

A managed API handles rate limiting, provider redundancy, and response normalization. Scavio: $0.005/credit, 500 free/mo, typed JSON across Google, Reddit, YouTube, Amazon. No self-hosting, no maintenance.

Multi-provider routing pattern

The resilient approach: configure multiple providers and route based on availability and cost. If the primary provider fails or is slow, fall back to the secondary. This is especially important for coding agents where a failed search can block an entire workflow.

import requests, os, time

PROVIDERS = {
    "scavio": {
        "url": "https://api.scavio.dev/api/v1/search",
        "headers": {"x-api-key": os.environ.get("SCAVIO_API_KEY", "")},
        "cost_per_call": 0.005,
    },
    "serper": {
        "url": "https://google.serper.dev/search",
        "headers": {"X-API-KEY": os.environ.get("SERPER_API_KEY", "")},
        "cost_per_call": 0.001,
    },
}

def search_with_fallback(query, num_results=5):
    """Try primary provider, fall back to secondary on failure."""
    errors = []
    for name, config in PROVIDERS.items():
        if not config["headers"].get("x-api-key") and not config["headers"].get("X-API-KEY"):
            continue  # Skip unconfigured providers

        try:
            start = time.time()
            resp = requests.post(
                config["url"],
                headers=config["headers"],
                json={"query": query, "num_results": num_results},
                timeout=5
            )
            elapsed = time.time() - start

            if resp.status_code == 200:
                data = resp.json()
                return {
                    "provider": name,
                    "results": data.get("results", []),
                    "latency_ms": int(elapsed * 1000),
                    "cost": config["cost_per_call"],
                }
        except Exception as e:
            errors.append({"provider": name, "error": str(e)})

    return {"provider": "none", "results": [], "errors": errors}

result = search_with_fallback("python async best practices 2026")
print(f"Provider: {result['provider']}, Results: {len(result['results'])}")

Routing strategies

• Primary/fallback: always try the cheapest or fastest provider first. Switch on failure. Simple and effective for most use cases.
• Cost-based: route low-priority queries to the cheapest provider, high-priority queries to the most reliable. Useful when you have budget constraints.
• Latency-based: measure response times and route to the fastest provider. Useful when the agent is interactive and latency matters.

The /reload pattern for MCP

After adding a new search provider as an MCP server, you need to reload the tool definitions. In Claude Code, run /reload. In Pi and similar agents, check the documentation for the equivalent command. Without reloading, the agent cannot see the new tools. This is a common gotcha that wastes debugging time.

Choosing for Pi specifically

For a coding agent like Pi, search is primarily used for documentation lookups, API reference checks, and debugging error messages. Volume is moderate (10-50 calls per coding session). At this volume, even the most expensive option (Exa at $7/1K) costs under $0.35 per session. The decision should be based on integration simplicity and result quality, not cost.

Recommendation by use case

• Quick setup, no ops: Tavily or Scavio with a single API key
• Maximum privacy, willing to maintain: SearxNG self-hosted
• Multi-platform results (Reddit, YouTube, etc.): Scavio
• Budget-constrained high volume: Serper at $1/1K calls
• Production resilience: multi-provider routing with fallback