Hello World Agent

"""Hello World ReAct agent — LangGraph."""

import os
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent


def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny, 72 F."


llm = ChatOpenAI(
    model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini"),
    base_url=os.environ.get("OPENAI_BASE_URL"),
    api_key=os.environ.get("OPENAI_API_KEY"),
)
agent = create_react_agent(
    llm,
    tools=[get_weather],
    prompt="You are a helpful assistant. When you receive a tool "
           "result, summarize it as a final answer.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in Portland?"}]}
)

for msg in result["messages"]:
    print(f"{msg.type}: {msg.content}")

"""Hello World agent — CrewAI."""

__import__("pysqlite3")
import sys
sys.modules["sqlite3"] = sys.modules.pop("pysqlite3")

import os
from crewai import Agent, Task, Crew, LLM
from crewai.tools import tool


@tool("get_weather")
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny, 72 F."


llm = LLM(
    model=f"openai/{os.environ.get('OPENAI_MODEL_NAME', 'gpt-4o-mini')}",
    base_url=os.environ.get("OPENAI_BASE_URL"),
    api_key=os.environ.get("OPENAI_API_KEY"),
)

agent = Agent(
    role="Weather Reporter",
    goal="Look up weather using the get_weather tool and summarize the result",
    backstory="You are a helpful weather assistant. Always use your tools "
              "to get data, then write a clear summary as your final answer.",
    llm=llm,
    tools=[get_weather],
    max_iter=5,
    max_retry_limit=3,
)

task = Task(
    description="What is the weather in Portland? Use the get_weather tool "
                "to find out, then respond with a one-sentence summary.",
    expected_output="A single sentence like: The weather in Portland is ...",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task])
result = crew.kickoff()
print(result.raw)

"""Hello World agent — AutoGen."""

import os
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient


def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny, 72 F."


model_name = os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini")
model_client = OpenAIChatCompletionClient(
    model=model_name,
    base_url=os.environ.get("OPENAI_BASE_URL"),
    api_key=os.environ.get("OPENAI_API_KEY"),
    model_info={
        "vision": False,
        "function_calling": True,
        "json_output": True,
        "structured_output": True,
        "family": "unknown",
    },
)

agent = AssistantAgent(
    name="weather_agent",
    model_client=model_client,
    tools=[get_weather],
)


async def main():
    result = await agent.run(task="What's the weather in Portland?")
    print(result.messages[-1].content)


asyncio.run(main())

"""Hello World ReAct agent — LlamaIndex."""

import os
import asyncio
from llama_index.core.agent.workflow import AgentWorkflow, ReActAgent
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai_like import OpenAILike


def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny, 72 F."


llm = OpenAILike(
    model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini"),
    api_base=os.environ.get("OPENAI_BASE_URL"),
    api_key=os.environ.get("OPENAI_API_KEY"),
    is_chat_model=True,
    is_function_calling_model=False,
    context_window=128000,
)

react_agent = ReActAgent(
    name="weather_agent",
    description="Looks up the weather",
    tools=[FunctionTool.from_defaults(fn=get_weather)],
    llm=llm,
)

agent = AgentWorkflow(agents=[react_agent], root_agent="weather_agent")


async def main():
    response = await agent.run("What's the weather in Portland?")
    print(response)


asyncio.run(main())

"""Hello World agent — Google ADK."""

import os
import asyncio
from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types


def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny, 72 F."


model = LiteLlm(
    model=f"openai/{os.environ.get('OPENAI_MODEL_NAME', 'gpt-4o-mini')}",
    api_base=os.environ.get("OPENAI_BASE_URL"),
    api_key=os.environ.get("OPENAI_API_KEY"),
)

agent = Agent(
    name="weather_agent",
    model=model,
    description="A helpful weather assistant",
    instruction="Help users check the weather. "
                "Use the get_weather tool when asked.",
    tools=[get_weather],
)

session_service = InMemorySessionService()
runner = Runner(
    agent=agent, app_name="weather_app",
    session_service=session_service,
)


async def main():
    session = await session_service.create_session(
        app_name="weather_app", user_id="user1",
    )
    message = types.Content(
        role="user",
        parts=[types.Part(text="What's the weather in Portland?")],
    )
    async for event in runner.run_async(
        user_id="user1", session_id=session.id,
        new_message=message,
    ):
        if event.is_final_response():
            print(event.content.parts[0].text)


asyncio.run(main())