Building a Google Search AI Agent with Python & LangChain

1. The Knowledge Boundary Problem in LLMs

Standard Large Language Models (LLMs) operate strictly within the boundaries of their parametric memory—the frozen weights established during pre-training. While LLMs excel at language synthesis, pattern recognition, and generalized reasoning, they suffer from two critical limitations:

1. Static Training Cutoffs: An LLM cannot natively access information created after its pre-training cutoff date (e.g., recent sporting tournaments, breaking news, or newly released box office figures).
2. Private/Hyper-Specific Data Gaps: An LLM cannot reliably access hyper-local, real-time, or niche institutional data (e.g., the exact physical address, current phone numbers, or updated operating hours of a specific educational institute), even if that data is publicly available on the web.

To resolve this limitation, we do not fine-tune the model on every incremental data change. Instead, we convert the LLM into an AI Agent. By equipping the model with an external web search interface (Google Search via Serper API), the LLM shifts from being a static encyclopedia to an active reasoning engine capable of browsing the web, retrieving ground-truth evidence, and synthesizing an accurate, up-to-date response.

2. Core Mental Model: ReAct Framework (Think, Act, Observe)

An AI Agent uses an LLM as its central reasoning engine, operating in a feedback loop commonly formulated as the ReAct (Reasoning + Acting) loop:

Real-Life Analogy

Imagine a research assistant sitting in an office with no smartphone. If you ask them a historical question, they answer immediately from memory. However, if you ask for the real-time box office numbers of a movie released yesterday, they do not invent a number. Instead, they Think ("I don't know this offhand"), Act (pick up their computer, open Google, and search for the box office receipts), Observe (read the top financial reports on the screen), and finally report back with the precise numbers. The agent created here operates by that exact procedure.

3. Tool Selection: Google Search API vs. Serper API

When integrating Google Search into LangChain workflows, developers typically evaluate two main providers:

For our agent, we use Serper API via LangChain's GoogleSerperAPIWrapper due to its zero-configuration onboarding and native LangChain compatibility.

4. Environment Setup and Dependency Installation

To build the agent, we need core LangChain packages, the LangChain Groq partner integration (for ultra-fast LLM inference), and the environment configuration utilities.

4.1 Dependency Installation

Add or verify the following dependencies in your requirements.txt:

langchain
langchain-community
langchain-groq
python-dotenv

Install them using pip:

pip install -r requirements.txt

4.2 API Keys & Environment Configuration

Acquire your API keys:

1. Groq Cloud API Key: From the Groq Console (for high-speed LLM inference).
2. Serper API Key: From https://serper.dev (sign up and copy the key from the dashboard).

Create a .env file in the root of your project:

# Serper API Key (must use this exact variable name for LangChain's auto-detection)
SERPER_API_KEY=your_serper_api_key_here

# Groq API Key
GROQ_API_KEY=your_groq_api_key_here

Note: GoogleSerperAPIWrapper automatically detects the environment variable named SERPER_API_KEY. If named differently, the key must be manually passed to the wrapper's constructor.

5. Prototyping in Jupyter: Step-by-Step Evolution

Before assembling the full agent, we verify the search tool and the LLM independently.

Step 1: Load Environment Variables and Import Modules

import os
from dotenv import load_dotenv

# Load keys from .env into execution environment
load_dotenv()

from langchain_community.utilities import GoogleSerperAPIWrapper
from langchain_groq import ChatGroq
from langchain.agents import create_agent

Step 2: Initialize LLM and Standalone Search Tool

We configure ChatGroq with an open-source, high-throughput model (such as a 20B/70B parameter open-weights model hosted on Groq) and instantiate GoogleSerperAPIWrapper.

# Initialize Groq LLM
llm = ChatGroq(
    model_name="openai/gpt-oss-20b", # Or Groq-supported models like llama-3.3-70b-versatile
    temperature=0.0
)

# Initialize Serper Wrapper
search = GoogleSerperAPIWrapper()

Step 3: Test the Search Tool Standalone

The .run() method of GoogleSerperAPIWrapper executes a search query against Google and returns a plain text string of concatenated search snippets:

raw_result = search.run("Address of Techspire Learnings")
print(raw_result)

Output:

Techspire Learnings, Plot No. 12, Sector 22, Near Metro Station, Gurugram, Haryana 122015...

Step 4: Construct the Agent

We pass the tool reference (search.run) inside a list to create_agent.

# Package tool into a list. Pass the function reference, NOT the function call.
tools = [search.run]

# Create the agent with model, tools, and system prompt
agent = create_agent(
    model=llm,
    tools=tools,
    system_prompt="You are an AI agent that can search Google to answer any user question accurately."
)

Critical Implementation Detail: Always pass search.run (the function reference), not search.run() (the executed call). The agent needs the callable function so it can choose when and with what arguments to execute it.

6. Dissecting the Agent Execution Trace

When an agent processes a query, it produces an internal sequence of conversational turns (messages) representing its reasoning chain.

# Formulate the payload using the standard LangChain message schema
query = "What is the contact address of Techspire Learnings?"

response = agent.invoke({
    "messages": [
        {"role": "user", "content": query}
    ]
})

Inspecting Intermediate Steps

The returned response["messages"] list captures every phase of the reasoning loop:

print(f"Total message steps executed: {len(response['messages'])}")

If len(response['messages']) equals 4, the trace breakdown is:

1. User Message: Initial question sent to the agent.
2. AI Action Message: Agent's decision to call the Google Search tool along with the extracted query.
3. Tool Message (Observation): The raw text returned from Google via Serper.
4. AI Message (Final Output): Synthesized response answering the user's initial question based on the observation.

To extract only the final parsed answer:

final_answer = response["messages"][-1].content
print(final_answer)

7. Interactive Terminal Chatbot Implementation

We can transition our prototyping script into an interactive command-line application featuring a continuous execution loop with graceful exit controls.

import os
import sys
from dotenv import load_dotenv
from langchain_community.utilities import GoogleSerperAPIWrapper
from langchain_groq import ChatGroq
from langchain.agents import create_agent

def initialize_search_agent():
    # 1. Load Environment Configuration
    load_dotenv()
    if not os.getenv("SERPER_API_KEY") or not os.getenv("GROQ_API_KEY"):
        raise EnvironmentError("Missing SERPER_API_KEY or GROQ_API_KEY in .env file.")

    # 2. Instantiate LLM & Search Components
    llm = ChatGroq(
        model_name="llama-3.3-70b-versatile",
        temperature=0.0
    )
    search = GoogleSerperAPIWrapper()

    # 3. Assemble Agent
    agent = create_agent(
        model=llm,
        tools=[search.run],
        system_prompt="You are an AI agent that can search Google to answer any user question accurately."
    )
    return agent

def run_chat_loop():
    agent = initialize_search_agent()
    print("==================================================")
    print("   Google Search AI Agent Initialized (Serper)   ")
    print("   Type 'quit' or 'exit' to terminate the session ")
    print("==================================================\n")

    while True:
        try:
            user_query = input("User: ").strip()
            
            # Handle blank inputs
            if not user_query:
                continue

            # Graceful Exit Strategy
            if user_query.lower() in ["quit", "exit"]:
                print("Agent: Goodbye!")
                sys.exit(0)

            # Invoke Agent Execution Loop
            response = agent.invoke({
                "messages": [
                    {"role": "user", "content": user_query}
                ]
            })

            # Extract the Terminal AI Content
            final_content = response["messages"][-1].content
            print(f"\nAI: {final_content}\n")

        except KeyboardInterrupt:
            print("\nSession interrupted. Exiting...")
            sys.exit(0)
        except Exception as e:
            print(f"\n[Error executing query]: {str(e)}\n")

if __name__ == "__main__":
    run_chat_loop()

8. Verification and Real-Time Evaluation Cases

The following real-world queries illustrate when the agent leverages its search tool versus answering immediately:

1. Static / Conversational Query:
   • Input: "Hello"
   • Behavior: Agent recognizes no factual lookup is needed; responds immediately without executing external API calls.
2. Post-Cutoff / Live Sporting Events:
   • Input: "Who won the Women's World Cup 2025?"
   • Behavior: Model recognizes the cutoff limit, triggers search.run("Women's World Cup 2025 winner"), receives real-time tournament logs, and returns the accurate outcome.
3. Dynamic Financial / Commercial Metrics:
   • Input: "What is the total box office collection of Pushpa 2?"
   • Behavior: Searches Google for certified collection databases, breaks the numbers down into domestic, worldwide, and overseas metrics, and presents structured figures.

9. Architectural Limitation: The Memory Deficit

While the search agent overcomes the model's knowledge cutoff, the implementation above reveals a structural limitation: statelessness.

The Multi-Turn Context Failure

Consider this dialogue progression:

User Query 1: "Who is the Prime Minister of India?"
Agent:        "The Prime Minister of India is Narendra Modi."

User Query 2: "What is his age?"
Agent:        "I am not sure who you are referring to."

Technical Root Cause

In our terminal loop, each user query creates a fresh payload containing only the latest message:

# Stateless payload: Does not include past conversation turns
agent.invoke({
    "messages": [
        {"role": "user", "content": user_query}
    ]
})

Because the agent receives zero message history from previous turns:

• The pronoun "his" has no antecedent referent.
• The LLM cannot resolve the entity without context.
• The agent fails to construct an accurate search query (e.g., searching for "age" instead of "Narendra Modi age").

Resolving this requires adding a Conversation Memory System (such as LangChain's ChatMessageHistory or passing the full accumulated message state across loop iterations), which will be implemented in subsequent chapters.

Summary and Key Takeaways

• Overcoming Parametric Limits: AI Agents overcome static knowledge boundaries and pre-training cutoffs by delegating real-time data retrieval to external tools.
• The ReAct Paradigm: Agents operate on an iterative loop of Thinking (reasoning on what to do), Acting (executing search tools), and Observing (evaluating raw web findings).
• Serper API Advantages: GoogleSerperAPIWrapper provides a clean, fast interface for Google Search queries that requires minimal setup and integrates smoothly with LangChain.
• Tool Passing Mechanics: Always pass raw function references (tools=[search.run]) rather than calling the function directly, allowing the agent runtime to control invocation timing and parameters.
• Message List Structure: Agent responses contain the full conversational trace. Indexing with [-1].content cleanly extracts the agent's final synthesized response.
• Dynamic Reasoning vs. Static Caching: The agent decides dynamically whether to run a web search based on the user's intent—bypassing tools for standard greetings and calling them for fresh factual queries.
• Statelessness Pitfall: Passing single-turn message dictionaries leaves the agent without conversational context, causing entity resolution errors during follow-up questions. Full multi-turn support requires an explicit conversation history buffer.