Chapter 10 — Build Your First Agent

# tools.py
import json
from datetime import datetime
from agents import function_tool
from tavily import TavilyClient
import os

tavily = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

@function_tool
def search_web(query: str) -> str:
    """Search the web for current information on a topic.
    Use this when you need up-to-date facts, news, or data.
    Returns a summary of the top search results."""
    results = tavily.search(query, max_results=5)
    output = []
    for r in results["results"]:
        output.append(f"**{r['title']}**\n{r['content']}\nSource: {r['url']}\n")
    return "\n---\n".join(output)

@function_tool
def save_to_file(filename: str, content: str) -> str:
    """Save research findings to a markdown file.
    Use this when the user asks you to save or export your findings."""
    # Sanitize filename
    safe_name = "".join(c for c in filename if c.isalnum() or c in "._- ")
    filepath = f"output/{safe_name}"
    os.makedirs("output", exist_ok=True)
    with open(filepath, "w") as f:
        f.write(f"# Research: {filename}\n")
        f.write(f"*Generated on {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n\n")
        f.write(content)
    return f"Saved to {filepath}"

@function_tool
def get_current_date() -> str:
    """Get the current date and time. Use this when you need to know today's date."""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# agent.py
from agents import Agent, Runner
from tools import search_web, save_to_file, get_current_date

research_agent = Agent(
    name="Research Assistant",
    instructions="""You are an expert research assistant. Your job is to help users 
    find accurate, up-to-date information on any topic.

    WORKFLOW:
    1. When given a research question, break it into specific search queries
    2. Search for information using the search_web tool
    3. Synthesize findings into a clear, well-organized answer
    4. Always cite your sources with URLs
    5. If asked to save findings, use the save_to_file tool

    GUIDELINES:
    - Be thorough — search multiple aspects of a topic
    - Be honest — if you can't find something, say so
    - Be concise — summarize, don't just paste raw results
    - Always verify claims with multiple sources when possible
    """,
    tools=[search_web, save_to_file, get_current_date],
    model="gpt-4o",
)

# Run interactively
if __name__ == "__main__":
    import asyncio
    
    async def main():
        print("🤖 Research Assistant ready! Type 'quit' to exit.\n")
        
        while True:
            user_input = input("You: ").strip()
            if user_input.lower() in ("quit", "exit", "q"):
                break
            
            result = await Runner.run(research_agent, user_input)
            print(f"\n🤖 Assistant: {result.final_output}\n")
    
    asyncio.run(main())

# langgraph_agent.py
import os
import json
from datetime import datetime
from typing import Annotated

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.graph import StateGraph, START, END, MessagesState
from langgraph.prebuilt import ToolNode, tools_condition
from langgraph.checkpoint.memory import MemorySaver
from tavily import TavilyClient

tavily = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

@tool
def search_web(query: str) -> str:
    """Search the web for current information on a topic."""
    results = tavily.search(query, max_results=5)
    output = []
    for r in results["results"]:
        output.append(f"**{r['title']}**\n{r['content']}\nSource: {r['url']}\n")
    return "\n---\n".join(output)

@tool
def save_to_file(filename: str, content: str) -> str:
    """Save research findings to a markdown file."""
    safe_name = "".join(c for c in filename if c.isalnum() or c in "._- ")
    filepath = f"output/{safe_name}"
    os.makedirs("output", exist_ok=True)
    with open(filepath, "w") as f:
        f.write(f"# Research: {filename}\n")
        f.write(f"*Generated on {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n\n")
        f.write(content)
    return f"Saved to {filepath}"

tools = [search_web, save_to_file]

# Continue in langgraph_agent.py

llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)

SYSTEM_PROMPT = """You are an expert research assistant. 
Search for accurate, up-to-date information. Always cite sources with URLs.
Be thorough — search multiple aspects of a topic.
Synthesize findings into clear, organized answers."""

def agent_node(state: MessagesState):
    """The thinking node — calls the LLM."""
    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response]}

# Build the graph
graph = StateGraph(MessagesState)

# Add nodes
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(tools))

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

# Compile with memory (enables conversation history)
memory = MemorySaver()
app = graph.compile(checkpointer=memory)

# Run interactively
if __name__ == "__main__":
    config = {"configurable": {"thread_id": "research-session-1"}}
    
    print("🤖 Research Assistant (LangGraph) ready! Type 'quit' to exit.\n")
    
    while True:
        user_input = input("You: ").strip()
        if user_input.lower() in ("quit", "exit", "q"):
            break
        
        result = app.invoke(
            {"messages": [("user", user_input)]},
            config=config,
        )
        
        last_message = result["messages"][-1]
        print(f"\n🤖 Assistant: {last_message.content}\n")

# Guardrail: limit the number of tool calls
MAX_TOOL_CALLS = 15

# OpenAI SDK: use max_turns
result = await Runner.run(research_agent, user_input, max_turns=MAX_TOOL_CALLS)

# LangGraph: use recursion_limit
result = app.invoke(
    {"messages": [("user", user_input)]},
    config={"configurable": {"thread_id": "1"}, "recursion_limit": MAX_TOOL_CALLS},
)

# Use with LangGraph
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.3", temperature=0).bind_tools(tools)
# Everything else stays the same!