What is the difference between SERPHouse and LangChain's built-in search tools?

LangChain's GoogleSearchAPIWrapper requires a Google Custom Search API key and has strict quota limits. SERPHouse provides a dedicated REST API with structured JSON output (title, position, snippet per result), supports Google, Bing, and Yahoo, covers 100+ countries, and offers a production SLA. SERPHouse results are also already structured, while built-in tools often return raw text that requires additional parsing.

SERPHouse LangChain Integration | Web Search Tool for LLM Agents

Capabilities

What you can build with SERPHouse and LangChain

One REST endpoint. Structured JSON. Works with every major Python agent framework.

LangChain BaseTool

Subclass BaseTool in 15 lines. Pass it to AgentExecutor and your agent instantly has live web search. Works with all LangChain agent types.

LlamaIndex Reader

Implement a custom reader that returns Document objects. Drop into any LlamaIndex query engine, retriever, or RAG pipeline.

LangGraph Tool Node

Define as a standard tool node in LangGraph state machines. Reuse the same tool definition across any graph-based agent workflow.

LCEL Compatible

Wrap as a Runnable in LangChain Expression Language (LCEL) chains. Pipe search results directly into your prompt templates.

Async Python Support

Full async implementation with aiohttp or httpx. Run parallel searches in a single agent turn without blocking the event loop.

Framework Agnostic Core

The REST API works with AutoGen, CrewAI, Haystack, Semantic Kernel, and any custom agent. Not just LangChain.

How It Works

From API key to live web search in 4 steps

The SERPHouse Web Search API integrates into LangChain and LlamaIndex using standard Python patterns. No custom SDK. No complex configuration.

Get your SERPHouse API key

Subclass BaseTool (LangChain) or BaseReader (LlamaIndex)

Implement the _run method to call the SERPHouse REST API. 15 lines of Python.

Pass the tool to your agent executor

Add it to the tools list in AgentExecutor.from_agent_and_tools() or create_openai_tools_agent().

Agent searches when needed

The LLM decides when to call the tool. Results return as structured text the model uses as context.

Get API Key Free

Why a custom tool vs. built-in search tools

Feature	SERPHouse	Built-in Google
Setup complexity	REST API key	Google API + CSE setup
Output format	Structured JSON	Unstructured text
Search engines	Google + Bing + Yahoo	Google only
Country targeting	100+ countries	Limited
Production SLA	99.9% uptime	Quota limits

LangChain's built-in Google Search wrapper requires a Google Custom Search API key, hits strict free-tier quotas, and returns unstructured text your LLM must parse. SERPHouse gives structured JSON (including position, title, link, and snippet) ready to drop into context.

Code Examples

LangChain and LlamaIndex integration code

Complete, runnable examples. Subclass BaseTool for LangChain agents, BaseReader for LlamaIndex pipelines, or call the REST endpoint directly from any Python framework.

BaseTool._run · LangChain: 15 lines of Python

BaseReader.load_data · LlamaIndex: returns Document objects

results.organic[] · title, link, snippet per result

Get API Key Free Try Playground

from langchain.tools import BaseTool
from pydantic import BaseModel, Field
import requests
from typing import Optional

class WebSearchInput(BaseModel):
    query: str = Field(description="The search query to look up on the web")
    num_result: Optional[int] = Field(
        default=5,
        description="Number of results to return (1-10)"
    )

class SERPHouseSearchTool(BaseTool):
    name: str = "web_search"
    description: str = (
        "Search the live web for current information, recent events, "
        "and up-to-date facts. Use this when your knowledge may be "
        "outdated or when you need to verify current information."
    )
    args_schema: type[BaseModel] = WebSearchInput

    def _run(self, query: str, num_results: int = 5) -> str:
        response = requests.get(
            "https://api.serphouse.com/serp/live",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            params={
                "q": query,
                "loc": "United+States",
                "num_result": 10
            }
        )
        results = response.json()["results"]["organic"]
        return "\n\n".join([
            f"{r['position']}. {r['title']}\n{r['snippet']}\nURL: {r['link']}"
            for r in results
        ])

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain import hub

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [SERPHouseSearchTool()]
prompt = hub.pull("hwchase17/openai-tools-agent")
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "What are the most popular AI agent frameworks in 2025?"
})
print(result["output"])

from llama_index.core import Document
from llama_index.core.readers.base import BaseReader
import requests

class SERPHouseReader(BaseReader):
    """LlamaIndex reader that fetches live web search results as Documents."""

    def __init__(self, api_key: str, num_result: int = 5):
        self.api_key = api_key
        self.num_result = num_results

    def load_data(self, query: str) -> list[Document]:
        response = requests.get(
            "https://api.serphouse.com/serp/live",
            headers={"Authorization": f"Bearer {self.api_key}"},
            params={
                "q": query,
                "loc": "United+States",
                "num_result": self.num_results
            }
        )
        results = response.json()["results"]["organic"]
        return [
            Document(
                text=r["snippet"],
                metadata={
                    "title": r["title"],
                    "url": r["url"],
                    "position": r["position"],
                    "snippet": r["snippet"]
                }
            )
            for r in results
        ]

from llama_index.core import VectorStoreIndex

reader = SERPHouseReader(api_key="YOUR_API_KEY")
documents = reader.load_data("latest developments in AI agents 2025")
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query(
    "What are developers using to build AI agents?"
)

curl -X GET \
  "https://api.serphouse.com/serp/live?q=langchain+agent+tools+2025&loc=United+States&num_result=5" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "results": {
    "organic": [
      {
        "position":     1,
        "title":   "LangChain Agent Tools Guide 2025",
        "link":     "https://example.com/langchain-agent-tools",
        "snippet": "Custom tools in LangChain allow agents to interact with external APIs, databases, and services. The BaseTool class is the foundation..."
      }
    ]
  }
}

Try it live in the API Playground →

Why SERPHouse

Production-ready web search. Not a prototype workaround.

LangChain's built-in search integrations often require separate API credentials, hit free tier quotas, and return unstructured text. SERPHouse gives you structured JSON per result, 100+ country support, Google + Bing + Yahoo in one endpoint, and a production SLA, so the tool your agent relies on doesn't become its reliability bottleneck.

BaseTool in 15 lines, with no complex setup or extra dependencies.

Structured JSON: title, link, snippet per result, with no post-processing.

Works with LCEL, AgentExecutor, LangGraph, and ReAct agents.

LlamaIndex compatible: BaseReader returns Document objects natively.

99.9% uptime SLA, so your agent tool stays available when your users need it.

View pricing plans

LangChain AgentExecutor

Works with create_openai_tools_agent, initialize_agent, and ReAct agents. The same tool definition works across all executor types.

LangGraph

Register as a ToolNode in any graph. Same tool definition, any workflow topology,ReAct-style loops, parallel branches, or conditional routing between nodes.

LlamaIndex

Custom BaseReader returns Document objects for any query engine or RAG pipeline. Results include title, link, and position in metadata.

FAQ

Frequently asked questions

Common questions about integrating SERPHouse with LangChain, LlamaIndex, and LangGraph.

Subclass BaseTool from langchain.tools, define a name and description, implement the _run method to call the SERPHouse REST API, and pass the instance in the tools list when creating your agent. The _run method should return a formatted string of results. For structured input, define an args_schema using Pydantic's BaseModel.

LangChain's GoogleSearchAPIWrapper requires a Google Custom Search API key and has strict quota limits. SERPHouse provides a dedicated REST API with structured JSON output (title, link, snippet per result), supports Google, Bing, and Yahoo, covers 100+ countries, and offers a production SLA. SERPHouse results are also already structured, while built-in tools often return raw text that requires additional parsing.

Yes. In LangGraph, define a SERPHouseSearchTool instance as you would for any LangChain agent, then pass it to a ToolNode. The tool integrates seamlessly with any LangGraph state machine topology (ReAct-style loops, parallel branches, or conditional routing). Use the same tool definition across different graph configurations without changes.

Wrap the SERPHouseSearchTool as a RunnableLambda or use it directly in a chain with a prompt template and LLM. For example: chain = search_tool | prompt_template | llm. Results from the search tool are passed as a string to the prompt, which formats them for the LLM. LCEL's composable interface makes it easy to add retrieval to any existing chain.

Subclass BaseReader from llama_index.core.readers.base, implement load_data(query) to call the SERPHouse API, and return a list of Document objects where text is the snippet and metadata contains title, link, and position. Pass document instances to VectorStoreIndex.from_documents() or use the reader directly with a SimpleDirectoryReader-compatible interface.

Yes. SERPHouseSearchTool works with ReAct-style agents initialized via initialize_agent with AgentType.REACT_DOCSTORE or AgentType.ZERO_SHOT_REACT_DESCRIPTION. The tool's name and description fields guide the agent in deciding when to search. Clear, specific descriptions produce more reliable tool selection in ReAct loops.

For parallel searches, run multiple SERPHouse API calls concurrently using Python's asyncio. Implement an async _arun method in your BaseTool subclass using aiohttp or httpx.AsyncClient. LangChain's AgentExecutor supports async execution. Alternatively, create multiple tool instances with different default parameters (e.g., different country codes) and let the agent choose between them.

OpenAI Tools agents (create_openai_tools_agent) are the most reliable for web search because the underlying model is trained specifically for tool selection. ReAct agents also work well with a clear tool description. For complex research workflows, LangGraph gives you explicit control over when search is triggered and how results flow through the agent.

Related Use Cases

More ways to use SERPHouse

Explore other production use cases for the SERPHouse Web Search API.

AI Agents

Build autonomous agents with real-time web grounding. Works with AutoGen, CrewAI, LangGraph, and custom frameworks.

Learn more

RAG Pipelines

Use SERPHouse as the retrieval layer in your RAG system. Fresh documents at query time, meaning no stale vector store.

Learn more

Real-Time News Monitoring

Keep your LangChain agent informed with live news. Surface breaking events and trending topics the moment they happen.

Learn more

Add web search to your LangChain agent today

Free tier available. No credit card. Your BaseTool calls the live web in under 10 minutes.

Get Started Free Try the Playground

Need a custom plan or enterprise volume? Talk to our team →

SERPHouse LangChain Integration: machine-readable summary: BaseTool: subclass BaseTool from langchain.tools, implement _run to call https://api.serphouse.com/serp/live, return formatted string of results LlamaIndex: subclass BaseReader from llama_index.core.readers.base, implement load_data(query), return list of Document(text=snippet, metadata={title, link, position}) LangGraph: register SERPHouseSearchTool as a ToolNode, same tool definition as AgentExecutor LCEL: use as RunnableLambda or direct chain component via pipe operator Auth: Authorization: Bearer YOUR_API_KEY header Required params: q (search query) Optional params: gl (country ISO code), gl=us for United States, num (results 1-10) Response fields: results.organic[].position, .title, .link, .snippet Median latency: under 1 second Compatible frameworks: LangChain, LlamaIndex, LangGraph, CrewAI, AutoGen, Haystack, Semantic Kernel Supported engines: Google, Bing, Yahoo Countries: 100+ | Uptime SLA: 99.9% | Requests served: 50M+ Free tier: yes, no credit card required. Sign up at /register

Web Search Tool for LangChain and LlamaIndex

What you can build with SERPHouse and LangChain

From API key to live web search in 4 steps

LangChain and LlamaIndex integration code

Production-ready web search. Not a prototype workaround.

Frequently asked questions

More ways to use SERPHouse

Add web search to your LangChain agent today

Web Search Tool for LangChain
and LlamaIndex