M00B: Hello World — Three Ways to Build an Agent

"""raw_agent.py — Hello World, hand-rolled tool-use loop with OpenAI SDK + Mistral."""
import json
from datetime import datetime
from zoneinfo import ZoneInfo
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",  # Ollama local endpoint
    api_key="ollama",                      # required by SDK but ignored by Ollama
)

# ---- Tool implementation (plain Python) ----
TIMEZONES = {
    "new york": "America/New_York",
    "london": "Europe/London",
    "tokyo": "Asia/Tokyo",
    "sydney": "Australia/Sydney",
    "san francisco": "America/Los_Angeles",
}

def get_time(city: str) -> str:
    tz_name = TIMEZONES.get(city.lower())
    if tz_name is None:
        return f"Unknown city: {city}. Known cities: {', '.join(TIMEZONES)}."
    now = datetime.now(ZoneInfo(tz_name))
    return now.strftime("%H:%M on %A, %d %b %Y")

# ---- Tool schema (OpenAI function-calling format) ----
TOOLS = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Get the current local time in a major city.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. Tokyo"}
            },
            "required": ["city"],
        },
    },
}]

# ---- The loop ----
def run_agent(user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]
    while True:
        resp = client.chat.completions.create(
            model="mistral",
            messages=messages,
            tools=TOOLS,
            tool_choice="auto",
        )
        msg = resp.choices[0].message

        # Step 2: did Mistral finish?
        if msg.tool_calls is None:
            return msg.content

        # Step 3+4: Mistral requested tool calls — dispatch each one.
        messages.append(msg)
        for tc in msg.tool_calls:
            args = json.loads(tc.function.arguments)
            if tc.function.name == "get_time":
                result_text = get_time(args["city"])
            else:
                result_text = f"Unknown tool: {tc.function.name}"
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": result_text,
            })
        # Step 5: loop back

if __name__ == "__main__":
    print(run_agent("What time is it in Tokyo right now?"))

"""crewai_agent.py — Hello World, CrewAI + Mistral via Ollama."""
from datetime import datetime
from zoneinfo import ZoneInfo
from crewai import Agent, Task, Crew
from crewai.tools import tool

TIMEZONES = {
    "new york": "America/New_York",
    "london": "Europe/London",
    "tokyo": "Asia/Tokyo",
    "sydney": "Australia/Sydney",
    "san francisco": "America/Los_Angeles",
}

# ---- Tool (docstring becomes the tool description) ----
@tool("Get City Time")
def get_time(city: str) -> str:
    """Get the current local time in a major city such as Tokyo or London."""
    tz_name = TIMEZONES.get(city.lower())
    if tz_name is None:
        return f"Unknown city: {city}. Known cities: {', '.join(TIMEZONES)}."
    now = datetime.now(ZoneInfo(tz_name))
    return now.strftime("%H:%M on %A, %d %b %Y")

# ---- Agent (role + goal + tool list) ----
time_agent = Agent(
    role="World Clock Assistant",
    goal="Answer natural-language questions about the current time in any major city.",
    backstory="You help travellers and remote teams find the local time anywhere in the world.",
    tools=[get_time],
    llm="ollama/mistral",   # LiteLLM format: provider/model
    verbose=False,
)

# ---- Task ----
task = Task(
    description="What time is it in Tokyo right now?",
    expected_output="The current local time in Tokyo, including the day of the week.",
    agent=time_agent,
)

# ---- Crew (orchestration) ----
crew = Crew(agents=[time_agent], tasks=[task], verbose=False)
result = crew.kickoff()
print(result)

"""langchain_agent.py — Hello World, LangChain + ChatOllama."""
from datetime import datetime
from zoneinfo import ZoneInfo
from langchain_community.chat_models import ChatOllama
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

TIMEZONES = {
    "new york": "America/New_York",
    "london": "Europe/London",
    "tokyo": "Asia/Tokyo",
    "sydney": "Australia/Sydney",
    "san francisco": "America/Los_Angeles",
}

# ---- Tool (docstring becomes the schema description) ----
@tool
def get_time(city: str) -> str:
    """Get the current local time in a major city such as Tokyo or London."""
    tz_name = TIMEZONES.get(city.lower())
    if tz_name is None:
        return f"Unknown city: {city}. Known cities: {', '.join(TIMEZONES)}."
    now = datetime.now(ZoneInfo(tz_name))
    return now.strftime("%H:%M on %A, %d %b %Y")

# ---- LLM (ChatOllama = local Mistral) ----
llm = ChatOllama(model="mistral")
tools = [get_time]

# ---- Prompt (LCEL: system + human + scratchpad placeholder) ----
prompt = ChatPromptTemplate.from_messages([
    ("system", "You help users find the current local time in any city. Always use the get_time tool."),
    ("human", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),  # LangChain injects tool call history here
])

# ---- Agent = LCEL chain: prompt | llm | tool dispatcher ----
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=False)

result = executor.invoke({"input": "What time is it in Tokyo right now?"})
print(result["output"])