from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.agents import initialize_agent, Tool, AgentType

# Initialize Gemini 2.0 Flash LLM
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash", 
    convert_system_message_to_human=True,
    temperature=0.7
)

# Define Teaching Agent Tools
def ask_math_agent(query: str) -> str:
    prompt = f"You are a math teacher. Answer this math question: {query}"
    return llm.invoke(prompt).content

def ask_science_agent(query: str) -> str:
    prompt = f"You are a science teacher. Answer this science question: {query}"
    return llm.invoke(prompt).content

def ask_history_agent(query: str) -> str:
    prompt = f"You are a history teacher. Answer this history question: {query}"
    return llm.invoke(prompt).content

# Define Tools for Principal Agent
tools = [
    Tool(name="AskMath", func=ask_math_agent, description="Use for math questions."),
    Tool(name="AskScience", func=ask_science_agent, description="Use for science questions."),
    Tool(name="AskHistory", func=ask_history_agent, description="Use for history questions."),
]

# Initialize Principal Agent (Router)
principal_agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    handle_parsing_errors=True
)

# Run the System
student_query = "What is the capital of France?"
response = principal_agent.run(student_query)
print(response)

student_query = "What is the square root of 144? also explain the process."
response = principal_agent.run(student_query)
print(response)

student_query = "Who was the second president of the United States?"
response = principal_agent.run(student_query)
print(response)

> Entering new AgentExecutor chain...

I need to find out who the second president of the United States was.
Action: AskHistory
Action Input: Who was the second president of the United States?
Observation: Ah, a classic! The second president of the United States was **John Adams**. He served from 1797 to 1801. A fascinating and often overlooked figure in American history, Adams was a key player in the American Revolution and a staunch advocate for independence. However, his presidency was marked by controversy and challenges, particularly surrounding the Alien and Sedition Acts. Definitely a period worth further exploration!
Thought: I have the answer.
Final Answer: John Adams

> Finished chain.
John Adams

math_teacher:
  role: "Math Teacher"
  goal: "Answer students' math questions clearly."
  backstory: >
    A passionate math educator skilled in algebra, calculus, and problem-solving.

science_teacher:
  role: "Science Teacher"
  goal: "Answer students' science questions clearly."
  backstory: >
    A curious scientist passionate about physics, chemistry, and biology.

history_teacher:
  role: "History Teacher"
  goal: "Answer students' history questions clearly."
  backstory: >
    A knowledgeable historian focused on events from ancient to modern times.

principal:
  role: "School Principal to route query to the right teacher"
  goal: "Route student queries to the appropriate teacher."
  backstory: >
    A wise principal who knows where each question belongs.

route_task:
  description: "Receive student query, i.e. {topic}, and delegate to correct teacher agent."
  expected_output: "The final answer from the most relevant teacher."
  agent: principal

math_task:
  description: "Answer the math question of {topic}."
  expected_output: "A detailed math answer."
  agent: math_teacher

science_task:
  description: "Answer the science question of {topic}."
  expected_output: "A clear science answer."
  agent: science_teacher

history_task:
  description: "Answer the history question of {topic}."
  expected_output: "A descriptive history answer."
  agent: history_teacher

from dotenv import load_dotenv
from crewai import Agent, Crew, Process, Task, LLM
from crewai.project import CrewBase, agent, crew, task

llm = LLM(
    model="gemini/gemini-2.0-flash",
    temperature=0.7,  # Adjust temperature for response variability
)

# Load environment variables from .env file
load_dotenv()

@CrewBase
class SchoolCrew:
    """Crew to route student queries to subject teachers"""

    @agent
    def principal(self) -> Agent:
        return Agent(
            config=self.agents_config['principal'],
            verbose=True,
            llm=llm,
        )

    @agent
    def math_teacher(self) -> Agent:
        return Agent(config=self.agents_config['math_teacher'], verbose=True, llm=llm)

    @agent
    def science_teacher(self) -> Agent:
        return Agent(config=self.agents_config['science_teacher'], verbose=True, llm=llm)

    @agent
    def history_teacher(self) -> Agent:
        return Agent(config=self.agents_config['history_teacher'], verbose=True, llm=llm)

    @task
    def route_task(self) -> Task:
        return Task(config=self.tasks_config['route_task'])

    @task
    def math_task(self) -> Task:
        return Task(config=self.tasks_config['math_task'])

    @task
    def science_task(self) -> Task:
        return Task(config=self.tasks_config['science_task'])

    @task
    def history_task(self) -> Task:
        return Task(config=self.tasks_config['history_task'])

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=[self.math_teacher(), self.science_teacher(), self.history_teacher(), self.social_studies_teacher()],
            manager_agent=self.principal(),
            tasks=[self.route_task(), self.math_task(), self.science_task(), self.history_task(), self.social_studies_task()],
            process=Process.hierarchical,  # Dynamic routing
            verbose=True
        )

import os
from crew import SchoolCrew

os.makedirs('output', exist_ok=True)

def run():
    inputs = {"topic": "What is the capital of France?"}
    result = SchoolCrew().crew().kickoff(inputs=inputs)
    print("\n=== FINAL RESPONSE ===\n", result.raw)

    inputs = {"topic": "What is the square root of 144? also explain the process."}
    result = SchoolCrew().crew().kickoff(inputs=inputs)
    print("\n=== FINAL RESPONSE ===\n", result.raw)

    inputs = {"topic": "Who was the first president of the United States?"}
    result = SchoolCrew().crew().kickoff(inputs=inputs)
    print("\n=== FINAL RESPONSE ===\n", result.raw)

if __name__ == "__main__":
    run()

import asyncio
from agents import Agent
from agents import Runner

math_agent = Agent(
    name="MathAgent",
    model="litellm/gemini/gemini-2.0-flash",
    instructions="You are a math expert. Provide clear and concise answers to math-related questions.",
)
science_agent = Agent(
    name="ScienceAgent",
    model="litellm/gemini/gemini-2.0-flash",
    instructions="You are a science expert. Provide clear and concise answers to science-related questions.",
)
history_agent = Agent(
    name="HistoryAgent",
    model="litellm/gemini/gemini-2.0-flash",
    instructions="You are a history expert. Provide clear and concise answers to history-related questions.",
)

principal_agent = Agent(
    name="TriggerAgent",
    model="litellm/gemini/gemini-2.0-flash",
    instructions="You are a trigger agent. You will delegate questions to the appropriate subject expert based on the topic.",
    handoffs=[math_agent, science_agent, history_agent]
)

async def main():
    result = await Runner.run(principal_agent, "What is the capital of France?")
    print(result.final_output)

    result = await Runner.run(principal_agent, "What is the square root of 144? also explain the process.")
    print(result.final_output)

    result = await Runner.run(principal_agent, "Who was the first president of the United States?")
    print(result.final_output)

asyncio.run(main())

Query: Who was the first president of the India?

Dr. Rajendra Prasad was the first president of India.

import asyncio
from google.adk.agents import Agent
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.genai import types # For creating message Content/Parts

# Initialize Agents with Gemini 2.0 Flash
math_agent = Agent(
    name="MathTeacher", 
    model="gemini-2.0-flash",
    description="A math teacher who answers math-related questions.",
    instruction="You are a helpful math teacher. You only answer math-related questions."
)
science_agent = Agent(
    name="ScienceTeacher", 
    model="gemini-2.0-flash",
    description="A science teacher who answers science-related questions.",
    instruction="You are a helpful science teacher. You only answer science-related questions."
)
history_agent = Agent(
    name="HistoryTeacher", 
    model="gemini-2.0-flash",
    description="A history teacher who answers history-related questions.",
    instruction="You are a helpful history teacher. You only answer history-related questions."
)

principal_agent = Agent(
    name="Principal", 
    model="gemini-2.0-flash",
    description="A principal who manages the school system and delegates queries to appropriate teachers.",
    instruction="You are the principal of the school. You delegate questions to the appropriate teacher based on the subject.",
    sub_agents=[math_agent, science_agent, history_agent]
)

# Set Up Session Service
session_service = InMemorySessionService()
app_name = "SchoolSystem"
user_id = "Student_042"
session_id = "Session_001"

async def call_agent_async(query: str, runner, user_id, session_id):
  """Sends a query to the agent and prints the final response."""
  print(f"\n>>> User Query: {query}")

  content = types.Content(role='user', parts=[types.Part(text=query)])

  final_response_text = "Agent did not produce a final response." # Default

  async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=content):
      print(f"  [Event] Author: {event.author}, Type: {type(event).__name__}, Final: {event.is_final_response()}, Content: {event.content}")

      if event.is_final_response():
          if event.content and event.content.parts:
             final_response_text = event.content.parts[0].text
          elif event.actions and event.actions.escalate: # Handle potential errors/escalations
             final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
          break

  print(f"<<< Agent Response: {final_response_text}")

async def get_agent_response():
    session = await session_service.create_session(app_name=app_name, user_id=user_id, session_id=session_id)
    runner_agent_team = Runner(
        agent=principal_agent,
        app_name=app_name,
        session_service=session_service
    )

    print("Runner Agent Team initialized.")

    await call_agent_async(
        "What is the Pythagorean theorem?",
        runner_agent_team, 
        user_id, 
        session_id
    )

    await call_agent_async(
        "What is the chemical formula for water?",
        runner_agent_team, 
        user_id, 
        session_id
    )

    await call_agent_async(
        "Who was the first president of the United States?",
        runner_agent_team, 
        user_id, 
        session_id
    )

    await call_agent_async(
        "Which agents are available in the system?",
        runner_agent_team,
        user_id,
        session_id
    )

asyncio.run(get_agent_response())

>>> User Query: What is the Pythagorean theorem?
<<< Agent Response: The Pythagorean theorem states that in a right triangle, the square of the length of the hypotenuse (the side opposite the right angle) is equal to the sum of the squares of the lengths of the other two sides. This can be written as:

a² + b² = c²

where:
*   a and b are the lengths of the two shorter sides (legs) of the right triangle
*   c is the length of the hypotenuse