two modes

app.py

@@ -1,16 +1,11 @@
 # ==============================================================================
-# Aura Mind Glow - Field Mode MVP v1.0
+# Aura Mind Glow - Main Application
 # ==============================================================================
 """
-This script launches a 100% offline-capable Gradio application for maize health diagnosis.
-It is the foundational MVP for the Aura Mind Glow project.
-
-Workflow:
-1.  A fine-tuned Unsloth/Gemma-3N vision model analyzes an uploaded image to
-    diagnose the plant's condition (e.g., "Phosphorus Deficiency").
-2.  A local RAG (Retrieval-Augmented Generation) pipeline uses the diagnosis
-    text to search an in-memory knowledge base for relevant remedies.
-3.  The diagnosis and the retrieved remedies are displayed to the user.
+This script launches the Aura Mind Glow application.
+It features two modes:
+1.  Field Mode (100% Offline): For quick diagnosis and remedy retrieval.
+2.  Connected Mode (Online): A conversational agent powered by the Google ADK.
 """
 
 # --- Step 0: Essential Imports ---
@@ -19,6 +14,8 @@ import torch
 from PIL import Image
 import os
 import warnings
+import socket
+import asyncio
 
 # Suppress potential warnings for a cleaner console
 warnings.filterwarnings("ignore")
@@ -28,23 +25,33 @@ os.environ["TORCH_COMPILE_DISABLE"] = "1" # Ensure torch compile is off
 from unsloth import FastVisionModel
 from transformers import AutoProcessor
 
-# LangChain and RAG components for the local knowledge base
+# LangChain and RAG components
 from langchain_community.vectorstores import FAISS
 from langchain_community.document_loaders import TextLoader
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
+# Google ADK
+from google.adk import Agent, Runner
+from google.adk.sessions import InMemorySessionService
+from google.genai import types
+
+# Custom Tools
+from tools import PlantDiagnosisTool, RemedyRetrievalTool
+
 print("✅ All libraries imported successfully.")
 
-# --- Step 1: Global Setup - Vision Model (The 'Diagnoser') ---
+# --- Step 1: Global Setup - Vision Model and RAG ---
 # This expensive setup runs only ONCE when the application starts.
 
-print("Performing initial setup for the Vision Model...")
+print("Performing initial setup for Vision Model and RAG...")
 VISION_MODEL = None
 PROCESSOR = None
+RETRIEVER = None
 ADAPTER_PATH = "surfiniaburger/maize-health-diagnosis-adapter"
 
 try:
+    # Load Vision Model
     VISION_MODEL, PROCESSOR = FastVisionModel.from_pretrained(
         model_name="unsloth/gemma-3n-E2B-it-unsloth-bnb-4bit",
         max_seq_length=2048,
@@ -55,18 +62,7 @@ try:
     VISION_MODEL.load_adapter(ADAPTER_PATH)
     print(f"✅ Vision model and adapter '{ADAPTER_PATH}' loaded successfully!")
 
-except Exception as e:
-    print(f"❌ CRITICAL ERROR during vision model loading: {e}")
-    # We will allow the app to launch so the user can see the error in the UI
-    pass
-
-# --- Step 2: Global Setup - RAG Knowledge Base (The 'Remedy Retriever') ---
-# We create an in-memory vector store with remedy information. This also runs only once.
-
-print("Building the RAG knowledge base for remedies...")
-RETRIEVER = None
-try:
-    # This text is our local, offline knowledge base.
+    # Build RAG Knowledge Base
     remedy_knowledge_text = """
     # Maize Health Guide
     ## Phosphorus Deficiency
@@ -89,132 +85,168 @@ try:
     **Symptoms:** Vigorous growth with lush, uniformly dark green leaves. No visible spots, lesions, or discoloration.
     **Local Remedy:** No remedy needed. Maintain good agricultural practices, including proper watering, fertilization, and pest management to keep the plant healthy.
     """
-
-    # Use LangChain to load and process the text
     with open("knowledge.txt", "w") as f:
         f.write(remedy_knowledge_text)
-
     loader = TextLoader("knowledge.txt")
     documents = loader.load()
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
     docs = text_splitter.split_documents(documents)
     embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
     db = FAISS.from_documents(docs, embeddings)
-
-    # Create the retriever object that will find the relevant remedies
-    RETRIEVER = db.as_retriever(search_kwargs={"k": 1}) # Retrieve the single most relevant remedy
+    RETRIEVER = db.as_retriever(search_kwargs={"k": 1})
     print("✅ RAG knowledge base and retriever created successfully!")
 
 except Exception as e:
-    print(f"❌ CRITICAL ERROR during RAG setup: {e}")
-    # Allow app to launch to show error
+    print(f"❌ CRITICAL ERROR during global setup: {e}")
     pass
 
-# --- Step 3: Define the Core Functions for the Gradio App ---
-
-def diagnose_plant_from_image(uploaded_image: Image.Image) -> str:
-    """
-    Takes a PIL Image and runs the fine-tuned vision model to get a diagnosis.
-    """
-    if VISION_MODEL is None or PROCESSOR is None or uploaded_image is None:
-        raise gr.Error("Vision model is not loaded. Cannot perform diagnosis. Check logs.")
+# --- Step 2: Initialize ADK Tools and Agent ---
 
-    image = uploaded_image.convert("RGB")
-    messages = [
-        {"role": "user", "content": [{"type": "text", "text": "What is the condition of this maize plant? Provide only the name of the condition."}, {"type": "image", "image": image}]}
-    ]
-    text_prompt = PROCESSOR.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = PROCESSOR(text=text_prompt, images=image, return_tensors="pt").to(VISION_MODEL.device)
+print("Initializing ADK Tools and Agent...")
+DIAGNOSIS_TOOL = None
+REMEDY_TOOL = None
+ADK_AGENT = None
+ADK_RUNNER = None
+SESSION_SERVICE = None
 
-    with torch.inference_mode():
-        outputs = VISION_MODEL.generate(**inputs, max_new_tokens=48, use_cache=True)
+try:
+    if VISION_MODEL and PROCESSOR and RETRIEVER:
+        DIAGNOSIS_TOOL = PlantDiagnosisTool(model=VISION_MODEL, processor=PROCESSOR)
+        REMEDY_TOOL = RemedyRetrievalTool(retriever=RETRIEVER)
+
+        ADK_AGENT = Agent(
+            name="AuraMindGlowAgent",
+            model="gemini-1.5-flash-001",
+            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]
+        )
+
+        SESSION_SERVICE = InMemorySessionService()
+        ADK_RUNNER = Runner(agent=ADK_AGENT, app_name="AuraMindGlow", session_service=SESSION_SERVICE)
+        print("✅ ADK Agent and Runner initialized successfully!")
+    else:
+        print("❌ Skipping ADK setup due to errors in model or RAG loading.")
 
-    response = PROCESSOR.batch_decode(outputs, skip_special_tokens=True)[0]
-    
-    # Clean up the model's output to get only the diagnosis
-    # This logic specifically finds the text after "model\n"
-    answer_start_index = response.rfind("model\n")
-    if answer_start_index != -1:
-        return response[answer_start_index + len("model\n"):
-    ].strip()
-    
-    # Fallback for a different output format
-    answer_start_index = response.rfind("assistant\n")
-    if answer_start_index != -1:
-        return response[answer_start_index + len("assistant\n"):
-    ].strip()
+except Exception as e:
+    print(f"❌ CRITICAL ERROR during ADK setup: {e}")
+    pass
 
-    return "Could not parse diagnosis from model output."
 
+# --- Step 3: Define Gradio UIs ---
 
-def get_diagnosis_and_remedy(uploaded_image: Image.Image) -> str:
-    """
-    This is the main function for the Gradio interface. It orchestrates the
-    100% offline diagnosis-to-remedy workflow.
+def create_field_mode_ui():
+    """Creates the Gradio UI for the offline Field Mode."""
+    
+    def get_diagnosis_and_remedy(uploaded_image: Image.Image) -> str:
+        if uploaded_image is None:
+            return "Please upload an image of a maize plant first."
+        if RETRIEVER is None:
+            raise gr.Error("Knowledge base is not loaded. Cannot find remedy. Check logs.")
+        
+        try:
+            diagnosis_tool = PlantDiagnosisTool(model=VISION_MODEL, processor=PROCESSOR)
+            diagnosis = diagnosis_tool(uploaded_image)
+            print(f"Diagnosis received: {diagnosis}")
+
+            if "Could not parse" in diagnosis:
+                return f"Sorry, I couldn't identify the condition from the image. Raw output: {diagnosis}"
+
+            remedy_tool = RemedyRetrievalTool(retriever=RETRIEVER)
+            remedy = remedy_tool(diagnosis)
+            
+            final_response = f"""
+            ## Diagnosis Report
+
+            **Condition Identified:**
+            ### {diagnosis}
+
+            ---
+
+            ## Suggested Remedy
+
+            {remedy}
+            """
+            print("Workflow complete. Returning response.")
+            return final_response
+
+        except Exception as e:
+            print(f"An error occurred during the analysis workflow: {e}")
+            raise gr.Error(f"An unexpected error occurred: {e}")
+
+    css = """
+    footer {visibility: hidden !important;}
+    .gradio-container {font-family: 'IBM Plex Sans', sans-serif;}
     """
-    if uploaded_image is None:
-        return "Please upload an image of a maize plant first."
-    if RETRIEVER is None:
-        raise gr.Error("Knowledge base is not loaded. Cannot find remedy. Check logs.")
-
-    try:
-        # Step 1: Get the initial diagnosis from the vision model.
-        print("Workflow Step 1: Running diagnosis...")
-        diagnosis = diagnose_plant_from_image(uploaded_image)
-        print(f"Diagnosis received: {diagnosis}")
-
-        if "Could not parse" in diagnosis:
-            return f"Sorry, I couldn't identify the condition from the image. Raw output: {diagnosis}"
-
-        # Step 2: Retrieve remedy from the local knowledge base.
-        print(f"Workflow Step 2: Retrieving remedy for '{diagnosis}' from local DB...")
-        retrieved_docs = RETRIEVER.invoke(diagnosis)
-
-        # Step 3: Format the output for the user.
-        remedy_text = retrieved_docs[0].page_content if retrieved_docs else "No specific remedy found in the knowledge base for this condition."
-
-        final_response = f"""
-        ## Diagnosis Report
-
-        **Condition Identified:**
-        ### {diagnosis}
-
-        ---
 
-        ## Suggested Remedy
-
-        {remedy_text}
-        """
-        print("Workflow complete. Returning response.")
-        return final_response
-
-    except Exception as e:
-        print(f"An error occurred during the analysis workflow: {e}")
-        raise gr.Error(f"An unexpected error occurred: {e}")
-
-
-# --- Step 4: Build and Launch the Gradio Interface ---
+    return gr.Interface(
+        fn=get_diagnosis_and_remedy,
+        inputs=gr.Image(type="pil", label="Upload Maize Plant Image", sources=["upload", "webcam"]),
+        outputs=gr.Markdown(label="Diagnosis and Remedy Report", value="The report will appear here..."),
+        title="🌽 Aura Mind Glow: Field Mode (Offline)",
+        description="**A 100% Offline-Capable Farming Assistant.** Upload an image of a maize plant. The AI will diagnose its condition and retrieve a treatment plan from its local knowledge base.",
+        article="<p style='text-align: center;'>Built with Unsloth, LangChain, and Gradio. Version 1.1</p>",
+        allow_flagging="never",
+        theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"),
+        css=css
+    )
 
-print("Building Gradio interface...")
+def create_connected_mode_ui():
+    """Creates the Gradio UI for the online Connected Mode."""
+    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, powered by Google's ADK. I can help you diagnose plant health, get remedies, and more. How can I help you today?")
+        
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(label="Your message")
+        clear = gr.Button("Clear")
+
+        async def user(user_message, history):
+            # This is a placeholder for image handling
+            # In a real implementation, we would handle image uploads here
+            return "", history + [[user_message, None]]
+
+        async def bot(history):
+            user_message = history[-1][0]
+            
+            # Create a session for the user
+            session = await SESSION_SERVICE.create_session(app_name="AuraMindGlow", user_id="user123", session_id="session123")
+            content = types.Content(role='user', parts=[types.Part(text=user_message)])
+            
+            # Stream the agent's response
+            events = ADK_RUNNER.run_async(user_id="user123", session_id="session123", new_message=content)
+            
+            history[-1][1] = ""
+            async for event in events:
+                if event.is_final_response():
+                    final_response = event.content.parts[0].text
+                    history[-1][1] = final_response
+                    yield history
+
+        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+            bot, chatbot, chatbot
+        )
+        clear.click(lambda: None, None, chatbot, queue=False)
+    
+    return demo
 
-# Custom CSS for a cleaner look
-css = """
-footer {visibility: hidden !important;}
-.gradio-container {font-family: 'IBM Plex Sans', sans-serif;}
-"""
+# --- Step 4: App Launcher ---
 
-demo = gr.Interface(
-    fn=get_diagnosis_and_remedy,
-    inputs=gr.Image(type="pil", label="Upload Maize Plant Image", sources=["upload", "webcam"]),
-    outputs=gr.Markdown(label="Diagnosis and Remedy Report", value="The report will appear here..."),
-    title="🌽 Aura Mind Glow: Field Mode MVP",
-    description="**A 100% Offline-Capable Farming Assistant.** Upload an image of a maize plant. The AI will diagnose its condition using a fine-tuned model and retrieve a treatment plan from its local knowledge base.",
-    article="<p style='text-align: center;'>Built with Unsloth, LangChain, and Gradio. Version 1.0</p>",
-    allow_flagging="never",
-    theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"),
-    css=css
-)
+def check_internet_connection(host="8.8.8.8", port=53, timeout=3):
+    """Check for internet connectivity."""
+    try:
+        socket.setdefaulttimeout(timeout)
+        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
+        return True
+    except socket.error:
+        return False
 
 if __name__ == "__main__":
-    print("Launching Gradio app...")
-    demo.launch(share=True, debug=True)
+    if check_internet_connection() and ADK_RUNNER:
+        print("✅ Internet connection detected. Launching Connected Mode.")
+        ui = create_connected_mode_ui()
+    else:
+        print("❌ No internet connection or ADK setup failed. Launching Field Mode (Offline).")
+        ui = create_field_mode_ui()
+    
+    ui.launch(share=True, debug=True)

miscellaneous/instructions.md

@@ -2872,3 +2872,261 @@ Next
 Built-in tools
 Copyright Google 2025
 Made with Material for MkDocs
+
+
+
+Third Party Tools¶
+python_only
+
+ADK is designed to be highly extensible, allowing you to seamlessly integrate tools from other AI Agent frameworks like CrewAI and LangChain. This interoperability is crucial because it allows for faster development time and allows you to reuse existing tools.
+
+1. Using LangChain Tools¶
+ADK provides the LangchainTool wrapper to integrate tools from the LangChain ecosystem into your agents.
+
+Example: Web Search using LangChain's Tavily tool¶
+Tavily provides a search API that returns answers derived from real-time search results, intended for use by applications like AI agents.
+
+Follow ADK installation and setup guide.
+
+Install Dependencies: Ensure you have the necessary LangChain packages installed. For example, to use the Tavily search tool, install its specific dependencies:
+
+
+pip install langchain_community tavily-python
+Obtain a Tavily API KEY and export it as an environment variable.
+
+
+export TAVILY_API_KEY=<REPLACE_WITH_API_KEY>
+Import: Import the LangchainTool wrapper from ADK and the specific LangChain tool you wish to use (e.g, TavilySearchResults).
+
+
+from google.adk.tools.langchain_tool import LangchainTool
+from langchain_community.tools import TavilySearchResults
+Instantiate & Wrap: Create an instance of your LangChain tool and pass it to the LangchainTool constructor.
+
+
+# Instantiate the LangChain tool
+tavily_tool_instance = TavilySearchResults(
+    max_results=5,
+    search_depth="advanced",
+    include_answer=True,
+    include_raw_content=True,
+    include_images=True,
+)
+
+# Wrap it with LangchainTool for ADK
+adk_tavily_tool = LangchainTool(tool=tavily_tool_instance)
+Add to Agent: Include the wrapped LangchainTool instance in your agent's tools list during definition.
+
+
+from google.adk import Agent
+
+# Define the ADK agent, including the wrapped tool
+my_agent = Agent(
+    name="langchain_tool_agent",
+    model="gemini-2.0-flash",
+    description="Agent to answer questions using TavilySearch.",
+    instruction="I can answer your questions by searching the internet. Just ask me anything!",
+    tools=[adk_tavily_tool] # Add the wrapped tool here
+)
+Full Example: Tavily Search¶
+Here's the full code combining the steps above to create and run an agent using the LangChain Tavily search tool.
+
+
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from google.adk import Agent, Runner
+from google.adk.sessions import InMemorySessionService
+from google.adk.tools.langchain_tool import LangchainTool
+from google.genai import types
+from langchain_community.tools import TavilySearchResults
+
+# Ensure TAVILY_API_KEY is set in your environment
+if not os.getenv("TAVILY_API_KEY"):
+    print("Warning: TAVILY_API_KEY environment variable not set.")
+
+APP_NAME = "news_app"
+USER_ID = "1234"
+SESSION_ID = "session1234"
+
+# Instantiate LangChain tool
+tavily_search = TavilySearchResults(
+    max_results=5,
+    search_depth="advanced",
+    include_answer=True,
+    include_raw_content=True,
+    include_images=True,
+)
+
+# Wrap with LangchainTool
+adk_tavily_tool = LangchainTool(tool=tavily_search)
+
+# Define Agent with the wrapped tool
+my_agent = Agent(
+    name="langchain_tool_agent",
+    model="gemini-2.0-flash",
+    description="Agent to answer questions using TavilySearch.",
+    instruction="I can answer your questions by searching the internet. Just ask me anything!",
+    tools=[adk_tavily_tool] # Add the wrapped tool here
+)
+
+async def setup_session_and_runner():
+    session_service = InMemorySessionService()
+    session = await session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
+    runner = Runner(agent=my_agent, app_name=APP_NAME, session_service=session_service)
+    return session, runner
+
+# Agent Interaction
+async def call_agent_async(query):
+    content = types.Content(role='user', parts=[types.Part(text=query)])
+    session, runner = await setup_session_and_runner()
+    events = runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content)
+
+    async for event in events:
+        if event.is_final_response():
+            final_response = event.content.parts[0].text
+            print("Agent Response: ", final_response)
+
+# 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("stock price of GOOG")
+2. Using CrewAI tools¶
+ADK provides the CrewaiTool wrapper to integrate tools from the CrewAI library.
+
+Example: Web Search using CrewAI's Serper API¶
+Serper API provides access to Google Search results programmatically. It allows applications, like AI agents, to perform real-time Google searches (including news, images, etc.) and get structured data back without needing to scrape web pages directly.
+
+Follow ADK installation and setup guide.
+
+Install Dependencies: Install the necessary CrewAI tools package. For example, to use the SerperDevTool:
+
+
+pip install crewai-tools
+Obtain a Serper API KEY and export it as an environment variable.
+
+
+export SERPER_API_KEY=<REPLACE_WITH_API_KEY>
+Import: Import CrewaiTool from ADK and the desired CrewAI tool (e.g, SerperDevTool).
+
+
+from google.adk.tools.crewai_tool import CrewaiTool
+from crewai_tools import SerperDevTool
+Instantiate & Wrap: Create an instance of the CrewAI tool. Pass it to the CrewaiTool constructor. Crucially, you must provide a name and description to the ADK wrapper, as these are used by ADK's underlying model to understand when to use the tool.
+
+
+# Instantiate the CrewAI tool
+serper_tool_instance = SerperDevTool(
+    n_results=10,
+    save_file=False,
+    search_type="news",
+)
+
+# Wrap it with CrewaiTool for ADK, providing name and description
+adk_serper_tool = CrewaiTool(
+    name="InternetNewsSearch",
+    description="Searches the internet specifically for recent news articles using Serper.",
+    tool=serper_tool_instance
+)
+Add to Agent: Include the wrapped CrewaiTool instance in your agent's tools list.
+
+
+from google.adk import Agent
+
+# Define the ADK agent
+my_agent = Agent(
+    name="crewai_search_agent",
+    model="gemini-2.0-flash",
+    description="Agent to find recent news using the Serper search tool.",
+    instruction="I can find the latest news for you. What topic are you interested in?",
+    tools=[adk_serper_tool] # Add the wrapped tool here
+)
+Full Example: Serper API¶
+Here's the full code combining the steps above to create and run an agent using the CrewAI Serper API search tool.
+
+
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from google.adk import Agent, Runner
+from google.adk.sessions import InMemorySessionService
+from google.adk.tools.crewai_tool import CrewaiTool
+from google.genai import types
+from crewai_tools import SerperDevTool
+
+
+# Constants
+APP_NAME = "news_app"
+USER_ID = "user1234"
+SESSION_ID = "1234"
+
+# Ensure SERPER_API_KEY is set in your environment
+if not os.getenv("SERPER_API_KEY"):
+    print("Warning: SERPER_API_KEY environment variable not set.")
+
+serper_tool_instance = SerperDevTool(
+    n_results=10,
+    save_file=False,
+    search_type="news",
+)
+
+adk_serper_tool = CrewaiTool(
+    name="InternetNewsSearch",
+    description="Searches the internet specifically for recent news articles using Serper.",
+    tool=serper_tool_instance
+)
+
+serper_agent = Agent(
+    name="basic_search_agent",
+    model="gemini-2.0-flash",
+    description="Agent to answer questions using Google Search.",
+    instruction="I can answer your questions by searching the internet. Just ask me anything!",
+    # Add the Serper tool
+    tools=[adk_serper_tool]
+)
+
+# Session and Runner
+async def setup_session_and_runner():
+    session_service = InMemorySessionService()
+    session = await session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
+    runner = Runner(agent=serper_agent, app_name=APP_NAME, session_service=session_service)
+    return session, runner
+
+
+# Agent Interaction
+async def call_agent_async(query):
+    content = types.Content(role='user', parts=[types.Part(text=query)])
+    session, runner = await setup_session_and_runner()
+    events = runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content)
+
+    async for event in events:
+        if event.is_final_response():
+            final_response = event.content.parts[0].text
+            print("Agent Response: ", final_response)
+
+# 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?")

tools.py

@@ -0,0 +1,69 @@
+# aura-mind-glow/tools.py
+
+import torch
+from PIL import Image
+from transformers import AutoProcessor
+from unsloth import FastVisionModel
+from langchain_community.vectorstores import FAISS
+
+class PlantDiagnosisTool:
+    """A tool to diagnose the condition of a maize plant from an image."""
+
+    def __init__(self, model: FastVisionModel, processor: AutoProcessor):
+        self.model = model
+        self.processor = processor
+        self.name = "PlantDiagnoser"
+        self.description = "Analyzes an image of a maize plant and returns a diagnosis of its health condition (e.g., 'Phosphorus Deficiency', 'Healthy Plant')."
+
+    def __call__(self, image: Image.Image) -> str:
+        """
+        Takes a PIL Image and returns the diagnosis string.
+        """
+        if self.model is None or self.processor is None or image is None:
+            return "Error: Vision model is not loaded or no image was provided."
+
+        image = image.convert("RGB")
+        messages = [
+            {"role": "user", "content": [{"type": "text", "text": "What is the condition of this maize plant? Provide only the name of the condition."}, {"type": "image", "image": image}]}
+        ]
+        text_prompt = self.processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        inputs = self.processor(text=text_prompt, images=image, return_tensors="pt").to(self.model.device)
+
+        with torch.inference_mode():
+            outputs = self.model.generate(**inputs, max_new_tokens=48, use_cache=True)
+
+        response = self.processor.batch_decode(outputs, skip_special_tokens=True)[0]
+
+        # Clean up the model's output to get only the diagnosis
+        answer_start_index = response.rfind("model\n")
+        if answer_start_index != -1:
+            return response[answer_start_index + len("model\n"):
+].strip()
+        
+        answer_start_index = response.rfind("assistant\n")
+        if answer_start_index != -1:
+            return response[answer_start_index + len("assistant\n"):
+].strip()
+
+        return "Could not parse diagnosis from model output."
+
+
+class RemedyRetrievalTool:
+    """A tool to retrieve remedies for a given plant diagnosis."""
+
+    def __init__(self, retriever: FAISS):
+        self.retriever = retriever
+        self.name = "RemedyRetriever"
+        self.description = "Takes a plant health diagnosis (e.g., 'Phosphorus Deficiency') and returns a suggested remedy from a local knowledge base."
+
+    def __call__(self, diagnosis: str) -> str:
+        """
+        Takes a diagnosis string and returns the remedy text.
+        """
+        if self.retriever is None:
+            return "Error: Knowledge base is not loaded."
+
+        retrieved_docs = self.retriever.invoke(diagnosis)
+        if retrieved_docs:
+            return retrieved_docs[0].page_content
+        return "No specific remedy found in the knowledge base for this condition."