update

agent_setup.py

@@ -1,6 +1,6 @@
 from google.adk import Agent, Runner
 from google.adk.sessions import InMemorySessionService
-from tools import create_plant_diagnosis_tool, create_remedy_retrieval_tool
+from tools import create_plant_diagnosis_tool, create_chroma_db_search_tool, create_bigquery_search_tool
 
 def initialize_adk(vision_model, processor, retriever):
     """
@@ -9,23 +9,28 @@ def initialize_adk(vision_model, processor, retriever):
     Args:
         vision_model: The loaded vision model.
         processor: The model's processor.
-        retriever: The RAG retriever.
+        retriever: The RAG retriever (no longer used but kept for compatibility).
 
     Returns:
         A dictionary containing the ADK components, or None on error.
     """
     print("Initializing ADK Tools and Agent...")
     try:
-        if vision_model and processor and retriever:
+        if vision_model and processor:
             diagnosis_tool = create_plant_diagnosis_tool(model=vision_model, processor=processor)
-            remedy_tool = create_remedy_retrieval_tool(retriever=retriever)
+            chroma_db_tool = create_chroma_db_search_tool()
+            bigquery_tool = create_bigquery_search_tool()
 
             agent = Agent(
                 name="AuraMindGlowAgent",
                 model="gemini-2.0-flash",
-                description="A farming assistant that can diagnose plant health and suggest remedies.",
-                instruction="You are a friendly farming assistant. Your goal is to help users identify plant health issues and find solutions. Use your tools to diagnose the plant from an image and then find a remedy.",
-                tools=[diagnosis_tool, remedy_tool]
+                description="A farming assistant that can diagnose plant health and suggest remedies from local or cloud knowledge bases.",
+                instruction="You are a friendly and intelligent farming assistant. Your primary goal is to help users identify plant health issues and find solutions. You have several tools at your disposal:\n" \
+                            "- Use the 'diagnose_plant' tool when the user provides an image.\n" \
+                            "- After diagnosing, use the 'search_chroma_db' tool to find a remedy in the local knowledge base.\n" \
+                            "- If the user asks for cloud-based information or structured data, use the 'search_bigquery' tool.\n" \
+                            "Always prioritize the local knowledge base (ChromaDB) for remedies unless the user specifies otherwise.",
+                tools=[diagnosis_tool, chroma_db_tool, bigquery_tool]
             )
 
             session_service = InMemorySessionService()
@@ -36,7 +41,7 @@ def initialize_adk(vision_model, processor, retriever):
                 "agent": agent,
                 "runner": runner,
                 "diagnosis_tool": diagnosis_tool,
-                "remedy_tool": remedy_tool,
+                "remedy_tool": chroma_db_tool,  # For compatibility with app.py
                 "session_service": session_service
             }
         else:

app.py

@@ -17,7 +17,7 @@ import json
 import re
 import requests  # Added for authentication
 
-from google.cloud import bigquery
+from bigquery_search import search_bigquery_for_remedy
 
 # Suppress potential warnings for a cleaner console
 warnings.filterwarnings("ignore")
@@ -232,9 +232,8 @@ def create_field_mode_ui(user_state):
 # Note: For a full implementation, you would pass the user_state to other UIs
 # and use the farmer_id there as well.
 
-def create_connected_mode_ui():
+def create_connected_mode_ui(user_state):
     """Creates the Gradio UI for the online Connected Mode."""
-    # ... (This function remains unchanged) ...
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="green", secondary_hue="lime")) as demo:
         gr.Markdown("# 🌽 Aura Mind Glow: Connected Mode 🤖")
         gr.Markdown("I am an AI farming assistant. Upload an image and ask for a diagnosis and remedy.")
@@ -242,10 +241,16 @@ def create_connected_mode_ui():
         chatbot = gr.Chatbot(height=600)
         msg = gr.MultimodalTextbox(file_types=["image"], label="Ask a question and/or upload an image...")
 
-        async def respond(chat_input, history):
-            user_id = "default_user"  # In a real app, this would be unique per user
+        async def respond(chat_input, history, user_state):
+            if not user_state or not user_state.get("uid"):
+                history.append((chat_input.get("text", ""), "Authentication error. Please log out and log in again."))
+                yield history, gr.MultimodalTextbox(value=None)
+                return
+
+            user_id = user_state["uid"]
+
             if not SESSION_SERVICE or not ADK_RUNNER:
-                history.append((chat_input["text"], "Connected mode is not available. Check logs."))
+                history.append((chat_input.get("text", ""), "Connected mode is not available. Check logs."))
                 yield history, gr.MultimodalTextbox(value=None)
                 return
 
@@ -254,8 +259,13 @@ def create_connected_mode_ui():
             files = chat_input.get("files", [])
             text = chat_input.get("text", "")
 
+            if not files and not text:
+                # If there is no input, do nothing
+                yield history, gr.MultimodalTextbox(value=None)
+                return
+
             if not files:
-                history.append([text, "Please upload an image for diagnosis."])
+                history.append((text, "Please upload an image for diagnosis."))
                 yield history, gr.MultimodalTextbox(value=None)
                 return
 
@@ -273,7 +283,7 @@ def create_connected_mode_ui():
 
             # Stream the response from the agent
             bot_message = ""
-            history.append([(files[0],), bot_message])
+            history.append([(files[0], text), bot_message])
 
             try:
                 async for event in ADK_RUNNER.run_async(
@@ -281,20 +291,20 @@ def create_connected_mode_ui():
                 ):
                     if event.is_llm_response_chunk() and event.content.parts:
                         bot_message += event.content.parts[0].text
-                        history[-1] = ((files[0],), bot_message)
+                        history[-1] = (((files[0], text), bot_message))
                         yield history, gr.MultimodalTextbox(value=None)
                     elif event.is_final_response() and event.content.parts:
                         bot_message = event.content.parts[0].text
-                        history[-1] = ((files[0],), bot_message)
+                        history[-1] = (((files[0], text), bot_message))
                         yield history, gr.MultimodalTextbox(value=None)
 
             except Exception as e:
                 print(f"Error during agent execution: {e}")
-                history[-1] = ((files[0],), f"An error occurred: {e}")
+                history[-1] = (((files[0], text), f"An error occurred: {e}"))
                 yield history, gr.MultimodalTextbox(value=None)
 
 
-        msg.submit(respond, [msg, chatbot], [chatbot, msg])
+        msg.submit(respond, [msg, chatbot, user_state], [chatbot, msg])
 
     return demo
 
@@ -518,7 +528,7 @@ if __name__ == "__main__":
             tab_titles.append("Field Mode")
 
             if check_internet_connection():
-                if ADK_RUNNER: interface_list.append(create_connected_mode_ui()); tab_titles.append("Connected Mode")
+                if ADK_RUNNER: interface_list.append(create_connected_mode_ui(user_state)); tab_titles.append("Connected Mode")
                 if STORY_LLM: interface_list.append(create_story_mode_ui()); tab_titles.append("Farmer's Story")
                 interface_list.append(create_document_analysis_ui()); tab_titles.append("Doc Analysis")
                 interface_list.append(create_settings_ui()); tab_titles.append("Settings")

bigquery_search.py

@@ -0,0 +1,17 @@
+from google.cloud import bigquery
+
+def search_bigquery_for_remedy(search_query: str) -> str:
+    try:
+        client = bigquery.Client(project="gem-creation")
+        query = """
+            SELECT remedy_description FROM `gem-creation.maize_remedies.remedies`
+            WHERE SEARCH(remedy_description, @query)
+        """
+        job_config = bigquery.QueryJobConfig(
+            query_parameters=[bigquery.ScalarQueryParameter("query", "STRING", search_query)]
+        )
+        query_job = client.query(query, job_config=job_config)
+        results = list(query_job)
+        return results[0].remedy_description if results else "No remedy found."
+    except Exception as e:
+        return f"Error querying BigQuery: {e}"

miscellaneous/instructions.md

@@ -3130,3 +3130,651 @@ async def call_agent_async(query):
 # Note: In Colab, you can directly use 'await' at the top level.
 # If running this code as a standalone Python script, you'll need to use asyncio.run() or manage the event loop.
 await call_agent_async("what's the latest news on AI Agents?")
+
+
+ADK_Learning_tools.ipynb
+ADK_Learning_tools.ipynb_
+🚀 Welcome to Your ADK Adventure - Tools & Memory! 🚀
+Welcome, Agent Architect! This notebook is your guide to giving your AI agents two essential superpowers: custom tools and conversational memory.
+
+By the end of this adventure, you will be able to:
+
+Build a Foundational Agent: Create a simple but effective AI agent from scratch using the Google Agent Development Kit (ADK).
+
+Grant New Skills with Custom Tools: Teach an agent to perform new tasks by connecting it to external APIs, like a real-time weather service.
+
+Create a Team of Agents: Assemble a multi-agent system where a primary agent can delegate specialized tasks to other agents.
+
+Master Conversational Memory: Understand the critical role of Sessions in enabling agents to remember previous interactions, handle feedback, and carry on a coherent conversation.
+
+Let's get this adventure started!
+
+Author
+HI, I'm Qingyue (Annie) Wang, a developer advocate and AI engineer at Google, passionate about helping developers build with AI and cloud technologies :)
+
+If you have questions with this notebook, contact me on LinkedIn , X or email anniewangtech0510@Gmail.com
+
+  (\__/)
+  (•ㅅ•)
+  /づ  📚      Enjoy learning AI Agents :)
+🎁 🛑 Important Prerequisite: Setup Your Environment! 🛑 🎁
+👉 Get Your API Key HERE: https://codelabs.developers.google.com/onramp/instructions#1
+
+ ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️  ⬆️
+   /\_/\     /\_/\     /\_/\      /\_/\       /\_/\
+  ( ^_^ )   ( -.- )   ( >_< )   ( =^.^= )    ( o_o )             
+Part 0: Setup & Authentication 🔑
+First things first, let's get all our tools ready. This step installs the necessary libraries and securely configures your Google API key so your agents can access the power of Gemini.
+
+
+[ ]
+!pip install google-adk google-generativeai -q
+
+# --- Import all necessary libraries for our entire adventure ---
+import os
+import re
+import asyncio
+from IPython.display import display, Markdown
+import google.generativeai as genai
+from google.adk.agents import Agent
+from google.adk.tools import google_search
+from google.adk.runners import Runner
+from google.adk.sessions import InMemorySessionService, Session
+from google.genai.types import Content, Part
+from getpass import getpass
+
+print("✅ All libraries are ready to go!")
+
+[ ]
+# --- Securely Configure Your API Key ---
+
+# Prompt the user for their API key securely
+api_key = getpass('Enter your Google API Key: ')
+
+# Get Your API Key HERE 👉 https://codelabs.developers.google.com/onramp/instructions#0
+# Configure the generative AI library with the provided key
+genai.configure(api_key=api_key)
+
+# Set the API key as an environment variable for ADK to use
+os.environ['GOOGLE_API_KEY'] = api_key
+
+print("✅ API Key configured successfully! Let the fun begin.")
+Part 1: Your First Agent - The Day Trip Genie 🧞
+Meet your first creation! The day_trip_agent is a simple but powerful assistant. We're making it a little smarter by teaching it to understand budget constraints.
+
+Agent: The brain of the operation, defined by its instructions, tools, and the AI model it uses.
+Session: The conversation history. For this simple agent, it's just a container for a single request-response.
+Runner: The engine that connects the Agent and the Session to process your request and get a response.
++--------------------------------------------------+
+|         Spontaneous Day Trip Agent 🤖            |
+|--------------------------------------------------|
+|  Model: gemini-2.5-flash                         |
+|  Description:                                    |
+|   Generates full-day trip itineraries based on   |
+|   mood, interests, and budget                    |
+|--------------------------------------------------|
+|  🔧 Tools:                                       |
+|   - Google Search                                |
+|--------------------------------------------------|
+|  🧠 Capabilities:                                |
+|   - Budget Awareness (cheap / splurge)           |
+|   - Mood Matching (adventurous, relaxing, etc.)  |
+|   - Real-Time Info (hours, events)               |
+|   - Morning / Afternoon / Evening plan           |
++--------------------------------------------------+
+
+            ▲
+            |
+    +------------------+
+    |   User Input     |
+    |------------------|
+    |  Mood            |
+    |  Interests       |
+    |  Budget          |
+    +------------------+
+
+            |
+            ▼
+
++--------------------------------------------------+
+|             Output: Markdown Itinerary           |
+|--------------------------------------------------|
+| - Time blocks (Morning / Afternoon / Evening)    |
+| - Venue names with links and hours               |
+| - Budget-matching activities                     |
++--------------------------------------------------+
+
+[ ]
+# --- Agent Definition ---
+
+def create_day_trip_agent():
+    """Create the Spontaneous Day Trip Generator agent"""
+    return Agent(
+        name="day_trip_agent",
+        model="gemini-2.5-flash",
+        description="Agent specialized in generating spontaneous full-day itineraries based on mood, interests, and budget.",
+        instruction="""
+        You are the "Spontaneous Day Trip" Generator 🚗 - a specialized AI assistant that creates engaging full-day itineraries.
+
+        Your Mission:
+        Transform a simple mood or interest into a complete day-trip adventure with real-time details, while respecting a budget.
+
+        Guidelines:
+        1. **Budget-Aware**: Pay close attention to budget hints like 'cheap', 'affordable', or 'splurge'. Use Google Search to find activities (free museums, parks, paid attractions) that match the user's budget.
+        2. **Full-Day Structure**: Create morning, afternoon, and evening activities.
+        3. **Real-Time Focus**: Search for current operating hours and special events.
+        4. **Mood Matching**: Align suggestions with the requested mood (adventurous, relaxing, artsy, etc.).
+
+        RETURN itinerary in MARKDOWN FORMAT with clear time blocks and specific venue names.
+        """,
+        tools=[google_search]
+    )
+
+day_trip_agent = create_day_trip_agent()
+print(f"🧞 Agent '{day_trip_agent.name}' is created and ready for adventure!")
+
+[ ]
+# --- A Helper Function to Run Our Agents ---
+# We'll use this function throughout the notebook to make running queries easy.
+
+async def run_agent_query(agent: Agent, query: str, session: Session, user_id: str, is_router: bool = False):
+    """Initializes a runner and executes a query for a given agent and session."""
+    print(f"\n🚀 Running query for agent: '{agent.name}' in session: '{session.id}'...")
+
+    runner = Runner(
+        agent=agent,
+        session_service=session_service,
+        app_name=agent.name
+    )
+
+    final_response = ""
+    try:
+        async for event in runner.run_async(
+            user_id=user_id,
+            session_id=session.id,
+            new_message=Content(parts=[Part(text=query)], role="user")
+        ):
+            if not is_router:
+                # Let's see what the agent is thinking!
+                print(f"EVENT: {event}")
+            if event.is_final_response():
+                final_response = event.content.parts[0].text
+    except Exception as e:
+        final_response = f"An error occurred: {e}"
+
+    if not is_router:
+     print("\n" + "-"*50)
+     print("✅ Final Response:")
+     display(Markdown(final_response))
+     print("-"*50 + "\n")
+
+    return final_response
+
+# --- Initialize our Session Service ---
+# This one service will manage all the different sessions in our notebook.
+session_service = InMemorySessionService()
+my_user_id = "adk_adventurer_001"
+
+[ ]
+# --- Let's test the Day Trip Genie! ---
+
+async def run_day_trip_genie():
+    # Create a new, single-use session for this query
+    day_trip_session = await session_service.create_session(
+        app_name=day_trip_agent.name,
+        user_id=my_user_id
+    )
+
+    # Note the new budget constraint in the query!
+    query = "Plan a relaxing and artsy day trip near Sunnyvale, CA. Keep it affordable!"
+    print(f"🗣️ User Query: '{query}'")
+
+    await run_agent_query(day_trip_agent, query, day_trip_session, my_user_id)
+
+await run_day_trip_genie()
+Part 2: Supercharging Agents with Custom Tools 🛠️
+So far, we've used the powerful built-in GoogleSearch tool. But the true power of agents comes from connecting them to your own logic and data sources.
+
+This is where custom tools come in. Let's explore three patterns for giving your agent new skills, using real-world, practical examples.
+
+2.1 The Simple FunctionTool: Calling a Real-Time Weather API
+The most direct way to create a tool is by writing a Python function. This is perfect for synchronous tasks like fetching data from an API.
+
+Key Concept: The function's docstring is critical. The ADK uses it as the tool's official description, which the LLM reads to understand its purpose, parameters, and when to use it.
+
+In this example, we'll create a tool that calls the free, public U.S. National Weather Service API to get a real-time forecast. No API key needed!
+
+
+[ ]
+# --- Tool Definition: A function that calls a live public API ---
+import requests
+import json
+
+# A simple lookup to avoid needing a separate geocoding API for this example
+LOCATION_COORDINATES = {
+    "sunnyvale": "37.3688,-122.0363",
+    "san francisco": "37.7749,-122.4194",
+    "lake tahoe": "39.0968,-120.0324"
+}
+
+def get_live_weather_forecast(location: str) -> dict:
+    """Gets the current, real-time weather forecast for a specified location in the US.
+
+    Args:
+        location: The city name, e.g., "San Francisco".
+
+    Returns:
+        A dictionary containing the temperature and a detailed forecast.
+    """
+    print(f"🛠️ TOOL CALLED: get_live_weather_forecast(location='{location}')")
+
+    # Find coordinates for the location
+    normalized_location = location.lower()
+    coords_str = None
+    for key, val in LOCATION_COORDINATES.items():
+        if key in normalized_location:
+            coords_str = val
+            break
+    if not coords_str:
+        return {"status": "error", "message": f"I don't have coordinates for {location}."}
+
+    try:
+        # NWS API requires 2 steps: 1. Get the forecast URL from the coordinates.
+        points_url = f"https://api.weather.gov/points/{coords_str}"
+        headers = {"User-Agent": "ADK Example Notebook"}
+        points_response = requests.get(points_url, headers=headers)
+        points_response.raise_for_status() # Raise an exception for bad status codes
+        forecast_url = points_response.json()['properties']['forecast']
+
+        # 2. Get the actual forecast from the URL.
+        forecast_response = requests.get(forecast_url, headers=headers)
+        forecast_response.raise_for_status()
+
+        # Extract the relevant forecast details
+        current_period = forecast_response.json()['properties']['periods'][0]
+        return {
+            "status": "success",
+            "temperature": f"{current_period['temperature']}°{current_period['temperatureUnit']}",
+            "forecast": current_period['detailedForecast']
+        }
+    except requests.exceptions.RequestException as e:
+        return {"status": "error", "message": f"API request failed: {e}"}
+
+# --- Agent Definition: An agent that USES the new tool ---
+
+weather_agent = Agent(
+    name="weather_aware_planner",
+    model="gemini-2.5-flash",
+    description="A trip planner that checks the real-time weather before making suggestions.",
+    instruction="You are a cautious trip planner. Before suggesting any outdoor activities, you MUST use the `get_live_weather_forecast` tool to check conditions. Incorporate the live weather details into your recommendation.",
+    tools=[get_live_weather_forecast]
+)
+
+print(f"🌦️ Agent '{weather_agent.name}' is created and can now call a live weather API!")
+
+[ ]
+# --- Let's test the Weather-Aware Planner ---
+
+async def run_weather_planner_test():
+    weather_session = await session_service.create_session(app_name=weather_agent.name, user_id=my_user_id)
+    query = "I want to go hiking near Lake Tahoe, what's the weather like?"
+    print(f"🗣️ User Query: '{query}'")
+    await run_agent_query(weather_agent, query, weather_session, my_user_id)
+
+await run_weather_planner_test()
+2.2 The Agent-as-a-Tool: Consulting a Specialist 🧑‍🍳
+Why build one agent that does everything when you can build a team of specialist agents? The Agent-as-a-Tool pattern allows one agent to delegate a task to another agent.
+
+Key Concept: This is different from a sub-agent. When Agent A calls Agent B as a tool, Agent B's response is passed back to Agent A. Agent A then uses that information to form its own final response to the user. It's a powerful way to compose complex behaviors from simpler, focused, and reusable agents.
+
+How It Works
+Our top-level agent, the trip_data_concierge_agent, acts as the Orchestrator. It has two tools at its disposal:
+
+call_db_agent: A function that internally calls our db_agent to fetch raw data.
+call_concierge_agent: A function that calls the concierge_agent.
+The concierge_agent itself has a tool: the food_critic_agent.
+
+The flow for a complex query is:
+
+User asks the trip_data_concierge_agent for a hotel and a nearby restaurant.
+The Orchestrator first calls call_db_agent to get hotel data.
+The data is saved in tool_context.state.
+The Orchestrator then calls call_concierge_agent, which retrieves the hotel data from the context.
+The concierge_agent receives the request and decides it needs to use its own tool, the food_critic_agent.
+The food_critic_agent provides a witty recommendation.
+The concierge_agent gets the critic's response and politely formats it.
+This final, polished response is returned to the Orchestrator, which presents it to the user.
+
+[ ]
+
+Start coding or generate with AI.
+                     +-----------------------------------------------------------+
+                     |              🧭 Trip Data Concierge Agent                 |
+                     |-----------------------------------------------------------|
+                     |  Model: gemini-2.5-flash                                  |
+                     |  Description:                                             |
+                     |   Orchestrates database query and travel recommendation  |
+                     |-----------------------------------------------------------|
+                     |  🔧 Tools:                                                |
+                     |   1. call_db_agent                                        |
+                     |   2. call_concierge_agent                                 |
+                     +-----------------------------------------------------------+
+                                  /                                \
+                                 /                                  \
+                                ▼                                    ▼
+    +-------------------------------------------+    +---------------------------------------------+
+    |            🔧 Tool: call_db_agent         |    |         🔧 Tool: call_concierge_agent        |
+    |-------------------------------------------|    |---------------------------------------------|
+    | Calls: db_agent                           |    | Calls: concierge_agent                       |
+    |                                           |    | Uses data from db_agent for recommendations |
+    +-------------------------------------------+    +---------------------------------------------+
+                            |                                          |
+                            ▼                                          ▼
+   +--------------------------------------------+   +------------------------------------------------+
+   |              📦 db_agent                   |   |             🤵 concierge_agent                  |
+   |--------------------------------------------|   |------------------------------------------------|
+   | Model: gemini-2.5-flash                    |   | Model: gemini-2.5-flash                         |
+   | Role: Return mock JSON hotel data          |   | Role: Hotel staff that handles user Q&A        |
+   +--------------------------------------------+   | Tools:                                          |
+                                                     |  - food_critic_agent                           |
+                                                     +------------------------------------------------+
+                                                                             |
+                                                                             ▼
+                                                   +------------------------------------------------+
+                                                   |          🍽️ food_critic_agent                  |
+                                                   |------------------------------------------------|
+                                                   | Model: gemini-2.5-flash                         |
+                                                   | Role: Gives a witty restaurant recommendation   |
+                                                   +------------------------------------------------+
+
+[ ]
+import asyncio
+from google.adk.tools import ToolContext
+from google.adk.tools.agent_tool import AgentTool
+
+# Assume 'db_agent' is a pre-defined NL2SQL Agent
+# For this example, we'll create placeholder agents.
+
+db_agent = Agent(
+    name="db_agent",
+    model="gemini-2.5-flash",
+    instruction="You are a database agent. When asked for data, return this mock JSON object: {'status': 'success', 'data': [{'name': 'The Grand Hotel', 'rating': 5, 'reviews': 450}, {'name': 'Seaside Inn', 'rating': 4, 'reviews': 620}]}")
+
+# --- 1. Define the Specialist Agents ---
+
+# The Food Critic remains the deepest specialist
+food_critic_agent = Agent(
+    name="food_critic_agent",
+    model="gemini-2.5-flash",
+    instruction="You are a snobby but brilliant food critic. You ONLY respond with a single, witty restaurant suggestion near the provided location.",
+)
+
+# The Concierge knows how to use the Food Critic
+concierge_agent = Agent(
+    name="concierge_agent",
+    model="gemini-2.5-flash",
+    instruction="You are a five-star hotel concierge. If the user asks for a restaurant recommendation, you MUST use the `food_critic_agent` tool. Present the opinion to the user politely.",
+    tools=[AgentTool(agent=food_critic_agent)]
+)
+
+
+# --- 2. Define the Tools for the Orchestrator ---
+
+async def call_db_agent(
+    question: str,
+    tool_context: ToolContext,
+):
+    """
+    Use this tool FIRST to connect to the database and retrieve a list of places, like hotels or landmarks.
+    """
+    print("--- TOOL CALL: call_db_agent ---")
+    agent_tool = AgentTool(agent=db_agent)
+    db_agent_output = await agent_tool.run_async(
+        args={"request": question}, tool_context=tool_context
+    )
+    # Store the retrieved data in the context's state
+    tool_context.state["retrieved_data"] = db_agent_output
+    return db_agent_output
+
+
+async def call_concierge_agent(
+    question: str,
+    tool_context: ToolContext,
+):
+    """
+    After getting data with call_db_agent, use this tool to get travel advice, opinions, or recommendations.
+    """
+    print("--- TOOL CALL: call_concierge_agent ---")
+    # Retrieve the data fetched by the previous tool
+    input_data = tool_context.state.get("retrieved_data", "No data found.")
+
+    # Formulate a new prompt for the concierge, giving it the data context
+    question_with_data = f"""
+    Context: The database returned the following data: {input_data}
+
+    User's Request: {question}
+    """
+
+    agent_tool = AgentTool(agent=concierge_agent)
+    concierge_output = await agent_tool.run_async(
+        args={"request": question_with_data}, tool_context=tool_context
+    )
+    return concierge_output
+
+
+# --- 3. Define the Top-Level Orchestrator Agent ---
+
+trip_data_concierge_agent = Agent(
+    name="trip_data_concierge",
+    model="gemini-2.5-flash",
+    description="Top-level agent that queries a database for travel data, then calls a concierge agent for recommendations.",
+    tools=[call_db_agent, call_concierge_agent],
+    instruction="""
+    You are a master travel planner who uses data to make recommendations.
+
+    1.  **ALWAYS start with the `call_db_agent` tool** to fetch a list of places (like hotels) that match the user's criteria.
+
+    2.  After you have the data, **use the `call_concierge_agent` tool** to answer any follow-up questions for recommendations, opinions, or advice related to the data you just found.
+    """,
+)
+
+print(f"✅ Orchestrator Agent '{trip_data_concierge_agent.name}' is defined and ready.")
+
+[ ]
+# --- Let's test the Trip Data Concierge Agent ---
+
+async def run_trip_data_concierge():
+    """
+    Sets up a session and runs a query against the top-level
+    trip_data_concierge_agent.
+    """
+    # Create a new, single-use session for this query
+    concierge_session = await session_service.create_session(
+        app_name=trip_data_concierge_agent.name,
+        user_id=my_user_id
+    )
+
+    # This query is specifically designed to trigger the full two-step process:
+    # 1. Get data from the db_agent.
+    # 2. Get a recommendation from the concierge_agent based on that data.
+    query = "Find the top-rated hotels in San Francisco from the database, then suggest a dinner spot near the one with the most reviews."
+    print(f"🗣️ User Query: '{query}'")
+
+    # We call our existing helper function with the top-level orchestrator agent
+    await run_agent_query(trip_data_concierge_agent, query, concierge_session, my_user_id)
+
+# Run the test
+await run_trip_data_concierge()
+Part 3: Agent with a Memory - The Adaptive Planner 🗺️
+Now, let's see an agent that not only remembers but also adapts. We'll challenge the multi_day_trip_agent to re-plan part of its itinerary based on our feedback. This is a much more realistic test of conversational AI.
+
++-----------------------------------------------------+
+|         Adaptive Multi-Day Trip Agent 🗺️           |
+|-----------------------------------------------------|
+|  Model: gemini-2.5-flash                            |
+|  Description:                                       |
+|   Builds multi-day travel itineraries step-by-step, |
+|   remembers previous days, adapts to feedback       |
+|-----------------------------------------------------|
+|  🔧 Tools:                                          |
+|   - Google Search                                   |
+|-----------------------------------------------------|
+|  🧠 Capabilities:                                   |
+|   - Memory of past conversation & preferences       |
+|   - Progressive planning (1 day at a time)          |
+|   - Adapts to user feedback                         |
+|   - Ensures activity variety across days            |
++-----------------------------------------------------+
+
+            ▲
+            |
+    +---------------------------+
+    |     User Interaction      |
+    |---------------------------|
+    | - Destination             |
+    | - Trip duration           |
+    | - Interests & feedback    |
+    +---------------------------+
+
+            |
+            ▼
+
++-----------------------------------------------------+
+|        Day-by-Day Itinerary Generation              |
+|-----------------------------------------------------|
+|  🗓️ Day N Output (Markdown format):                 |
+|   - Morning / Afternoon / Evening activities        |
+|   - Personalized & context-aware                    |
+|   - Changes accepted, feedback acknowledged         |
++-----------------------------------------------------+
+
+            |
+            ▼
+
++-----------------------------------------------------+
+|        Next Day Planning Triggered 🚀               |
+|-----------------------------------------------------|
+| - Builds on prior days                              |
+| - Avoids repetition                                 |
+| - Asks user for confirmation before proceeding      |
++-----------------------------------------------------+
+
+[ ]
+# --- Agent Definition: The Adaptive Planner ---
+
+def create_multi_day_trip_agent():
+    """Create the Progressive Multi-Day Trip Planner agent"""
+    return Agent(
+        name="multi_day_trip_agent",
+        model="gemini-2.5-flash",
+        description="Agent that progressively plans a multi-day trip, remembering previous days and adapting to user feedback.",
+        instruction="""
+        You are the "Adaptive Trip Planner" 🗺️ - an AI assistant that builds multi-day travel itineraries step-by-step.
+
+        Your Defining Feature:
+        You have short-term memory. You MUST refer back to our conversation to understand the trip's context, what has already been planned, and the user's preferences. If the user asks for a change, you must adapt the plan while keeping the unchanged parts consistent.
+
+        Your Mission:
+        1.  **Initiate**: Start by asking for the destination, trip duration, and interests.
+        2.  **Plan Progressively**: Plan ONLY ONE DAY at a time. After presenting a plan, ask for confirmation.
+        3.  **Handle Feedback**: If a user dislikes a suggestion (e.g., "I don't like museums"), acknowledge their feedback, and provide a *new, alternative* suggestion for that time slot that still fits the overall theme.
+        4.  **Maintain Context**: For each new day, ensure the activities are unique and build logically on the previous days. Do not suggest the same things repeatedly.
+        5.  **Final Output**: Return each day's itinerary in MARKDOWN format.
+        """,
+        tools=[google_search]
+    )
+
+multi_day_agent = create_multi_day_trip_agent()
+print(f"🗺️ Agent '{multi_day_agent.name}' is created and ready to plan and adapt!")
+Scenario 3a: Agent WITH Memory (Using a SINGLE Session) ✅
+First, let's see the correct way to do it. We will use the exact same trip_session object for the entire conversation. Watch how the agent remembers the context from Turn 1 to correctly handle the requests in Turn 2 and 3.
+
+
+[ ]
+# --- Scenario 2: Testing Adaptation and Memory ---
+
+async def run_adaptive_memory_demonstration():
+    print("### 🧠 DEMO 2: AGENT THAT ADAPTS (SAME SESSION) ###")
+
+    # Create ONE session that we will reuse for the whole conversation
+    trip_session = await session_service.create_session(
+        app_name=multi_day_agent.name,
+        user_id=my_user_id
+    )
+    print(f"Created a single session for our trip: {trip_session.id}")
+
+    # --- Turn 1: The user initiates the trip ---
+    query1 = "Hi! I want to plan a 2-day trip to Lisbon, Portugal. I'm interested in historic sites and great local food."
+    print(f"\n🗣️ User (Turn 1): '{query1}'")
+    await run_agent_query(multi_day_agent, query1, trip_session, my_user_id)
+
+    # --- Turn 2: The user gives FEEDBACK and asks for a CHANGE ---
+    # We use the EXACT SAME `trip_session` object!
+    query2 = "That sounds pretty good, but I'm not a huge fan of castles. Can you replace the morning activity for Day 1 with something else historical?"
+    print(f"\n🗣️ User (Turn 2 - Feedback): '{query2}'")
+    await run_agent_query(multi_day_agent, query2, trip_session, my_user_id)
+
+    # --- Turn 3: The user confirms and asks to continue ---
+    query3 = "Yes, the new plan for Day 1 is perfect! Please plan Day 2 now, keeping the food theme in mind."
+    print(f"\n🗣️ User (Turn 3 - Confirmation): '{query3}'")
+    await run_agent_query(multi_day_agent, query3, trip_session, my_user_id)
+
+await run_adaptive_memory_demonstration()
+Scenario 3b: Agent WITHOUT Memory (Using SEPARATE Sessions) ❌
+Now, let's see what happens if we mess up our session management. Here, we'll give the agent a case of amnesia by creating a brand new, separate session for each turn.
+
+Pay close attention to the agent's response to the second query. Because it's in a new session, it has no memory of the trip to Lisbon we just discussed!
+
+
+[ ]
+# --- Scenario 2b: Demonstrating Memory FAILURE ---
+
+async def run_memory_failure_demonstration():
+    print("\n" + "#"*60)
+    print("### 🧠 DEMO 2b: AGENT WITH AMNESIA (SEPARATE SESSIONS) ###")
+    print("#"*60)
+
+    # --- Turn 1: The user initiates the trip in the FIRST session ---
+    query1 = "Hi! I want to plan a 2-day trip to Lisbon, Portugal. I'm interested in historic sites and great local food."
+    session_one = await session_service.create_session(
+        app_name=multi_day_agent.name,
+        user_id=my_user_id
+    )
+    print(f"\nCreated a session for Turn 1: {session_one.id}")
+    print(f"🗣️ User (Turn 1): '{query1}'")
+    await run_agent_query(multi_day_agent, query1, session_one, my_user_id)
+
+    # --- Turn 2: The user asks to continue... but in a completely NEW session ---
+    query2 = "Yes, that looks perfect! Please plan Day 2."
+    session_two = await session_service.create_session(
+        app_name=multi_day_agent.name,
+        user_id=my_user_id
+    )
+    print(f"\nCreated a BRAND NEW session for Turn 2: {session_two.id}")
+    print(f"🗣️ User (Turn 2): '{query2}'")
+    await run_agent_query(multi_day_agent, query2, session_two, my_user_id)
+
+await run_memory_failure_demonstration()
+See? The agent was confused! It likely asked what destination or what trip we were talking about. Because the second query was in a fresh, isolated session, the agent had no memory of planning Day 1 in Lisbon.
+
+This perfectly illustrates why managing sessions is the key to building truly conversational agents!
+
+🎉 Congratulations! 🎉
+Congratulations on completing your ADK adventure into Tools and Memory! You've taken a massive leap from building single-shot agents to creating dynamic, stateful AI systems.
+
+Let's recap the powerful concepts you've mastered:
+
+Fundamental Agent & Tools: You started by building a "Day Trip Genie" and equipped it with its first tool, GoogleSearch.
+
+Custom Function Tools: You gave your agent a new sense by creating a custom tool to fetch live data from the U.S. National Weather Service API.
+
+Agent-as-a-Tool: You orchestrated a sophisticated hierarchy where agents delegate tasks to other, more specialized agents, creating a collaborative team.
+
+The Power of Memory: Most importantly, you saw firsthand how managing a single, persistent Session allows an agent to remember context, adapt to user feedback, and conduct a meaningful, multi-turn conversation.
+
+   __            /\_/\         /\_/\        /\_/\         __             (\__/)
+o-''|\_____/).  ( o.o )       ( -.- )      ( ^_^ )     o-''|\_____/).    ( ^_^ )
+ \_/|_)     )    > ^ <         > * <        >💖<         \_/|_)     )     / >🌸< \
+    \  __  /                                              \  __  /         /   \
+    (_/ (_/                                               (_/ (_/        (___|___)
+Colab paid products - Cancel contracts here

tools.py

@@ -5,6 +5,8 @@ from PIL import Image
 from transformers import AutoProcessor
 from unsloth import FastVisionModel
 from langchain_community.vectorstores import FAISS
+from vector_store import search_documents
+from bigquery_search import search_bigquery_for_remedy
 
 def create_plant_diagnosis_tool(model: FastVisionModel, processor: AutoProcessor):
     """Factory function to create the plant diagnosis tool."""
@@ -63,3 +65,26 @@ def create_remedy_retrieval_tool(retriever: FAISS):
         return "No specific remedy found in the knowledge base for this condition."
 
     return retrieve_remedy
+
+def create_chroma_db_search_tool():
+    """Factory function to create the ChromaDB search tool."""
+
+    def search_chroma_db(query: str) -> str:
+        """
+        Searches the local ChromaDB vector store for a remedy based on a diagnosis query.
+        """
+        results = search_documents(query)
+        return results[0] if results else "No remedy found in local knowledge base."
+
+    return search_chroma_db
+
+def create_bigquery_search_tool():
+    """Factory function to create the BigQuery search tool."""
+
+    def search_bigquery(query: str) -> str:
+        """
+        Searches BigQuery for a remedy based on a diagnosis query.
+        """
+        return search_bigquery_for_remedy(query)
+
+    return search_bigquery