Chapter 9 — Agentic Frameworks & SDKs

from langgraph.graph import StateGraph, START, END, MessagesState
from langgraph.prebuilt import ToolNode, tools_condition
from langchain_openai import ChatOpenAI

# Define tools
def search(query: str) -> str:
    """Search the web for information."""
    return tavily_client.search(query)

def calculator(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))  # simplified

tools = [search, calculator]
llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)

# Define the agent node
def agent(state: MessagesState):
    return {"messages": [llm.invoke(state["messages"])]}

# Build the graph
graph = StateGraph(MessagesState)
graph.add_node("agent", agent)
graph.add_node("tools", ToolNode(tools))

graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", tools_condition)  # agent → tools or END
graph.add_edge("tools", "agent")  # tools → back to agent

app = graph.compile()

# Run it
result = app.invoke({"messages": [("user", "What is 25 * 73?")]})

from agents import Agent, Runner, function_tool

@function_tool
def search_web(query: str) -> str:
    """Search the web for current information."""
    return tavily_client.search(query)

@function_tool
def read_file(path: str) -> str:
    """Read the contents of a file."""
    with open(path) as f:
        return f.read()

agent = Agent(
    name="Research Assistant",
    instructions="""You are a helpful research assistant. 
    Search the web for factual answers. Always cite your sources.""",
    tools=[search_web, read_file],
    model="gpt-4o",
)

# Run synchronously
result = Runner.run_sync(agent, "What are the latest advances in quantum computing?")
print(result.final_output)

from agents import Agent, handoff

math_agent = Agent(
    name="Math Tutor",
    instructions="Help with math problems. Show your work step by step.",
    tools=[calculator],
)

writing_agent = Agent(
    name="Writing Coach",
    instructions="Help improve writing. Give specific, actionable feedback.",
)

triage_agent = Agent(
    name="Triage",
    instructions="Determine if the user needs math help or writing help.",
    handoffs=[
        handoff(math_agent, "Math questions or calculations"),
        handoff(writing_agent, "Writing or grammar questions"),
    ],
)

result = Runner.run_sync(triage_agent, "Can you help me solve x^2 + 5x + 6 = 0?")
# → Hands off to math_agent

from crewai import Agent, Task, Crew

# Define agents with roles
researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive, accurate information on the topic",
    backstory="You're a veteran analyst with 20 years of experience.",
    tools=[search_tool, scrape_tool],
    llm="gpt-4o",
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging content from research findings",
    backstory="You write for top tech publications.",
    llm="gpt-4o",
)

# Define tasks
research_task = Task(
    description="Research the latest developments in AI agents for 2026",
    agent=researcher,
    expected_output="Detailed research notes with sources",
)

writing_task = Task(
    description="Write a blog post based on the research",
    agent=writer,
    expected_output="A polished 1000-word blog post",
    context=[research_task],  # depends on research
)

# Create and run the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True,
)

result = crew.kickoff()

from autogen import ConversableAgent

assistant = ConversableAgent(
    name="assistant",
    system_message="You are a helpful AI assistant.",
    llm_config={"model": "gpt-4o"},
)

user_proxy = ConversableAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"},
)

# Agents chat with each other
user_proxy.initiate_chat(
    assistant,
    message="Write a Python function to find prime numbers using the Sieve of Eratosthenes.",
)

from smolagents import CodeAgent, HfApiModel, tool

@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # ... implementation
    return f"{city}: 72°F, Sunny"

agent = CodeAgent(
    tools=[get_weather],
    model=HfApiModel("Qwen/Qwen2.5-72B-Instruct"),
)

result = agent.run("What's the weather like in Tokyo?")