How to Build AI Agents

# Create project directory
mkdir my-first-agent && cd my-first-agent

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install langchain langgraph langchain-openai python-dotenv

# Create .env file for API keys
echo "OPENAI_API_KEY=your-key-here" > .env

from langchain_core.tools import tool
from typing import Annotated

@tool
def web_search(query: Annotated[str, "The search query"]) -> str:
    """Search the web for current information on a topic."""
    # In production, integrate with a search API like Tavily or SerpAPI
    # For this example, we return mock results
    return f"Search results for: {query}"

@tool
def calculate(expression: Annotated[str, "Math expression to evaluate"]) -> str:
    """Evaluate a mathematical expression."""
    try:
        result = eval(expression)  # Use safer alternatives in production
        return str(result)
    except Exception as e:
        return f"Error: {str(e)}"

tools = [web_search, calculate]

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv

load_dotenv()

# Initialize the LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Create the agent with tools
agent = create_react_agent(
    llm,
    tools,
    state_modifier="""You are a helpful research assistant.
    Always search for current information before answering.
    Cite your sources and be accurate."""
)

# Run the agent
result = agent.invoke({
    "messages": [("user", "What is the population of Tokyo in 2026?")]
})

print(result["messages"][-1].content)

from langgraph.checkpoint.memory import MemorySaver

# Create a memory store for persistence
memory = MemorySaver()

# Create agent with memory
agent_with_memory = create_react_agent(
    llm,
    tools,
    checkpointer=memory,
    state_modifier="You are a helpful assistant with memory."
)

# Configuration for thread-based memory
config = {"configurable": {"thread_id": "user-123"}}

# First interaction
result1 = agent_with_memory.invoke(
    {"messages": [("user", "My name is Alex.")]},
    config=config
)

# Second interaction - agent remembers the name
result2 = agent_with_memory.invoke(
    {"messages": [("user", "What is my name?")]},
    config=config
)

print(result2["messages"][-1].content)  # "Your name is Alex."

SYSTEM_PROMPT = """You are an expert research assistant with access to tools.

## Your Role
- Provide accurate, well-researched answers
- Always cite sources when using search results
- Acknowledge uncertainty when appropriate

## Available Tools
- web_search: Search for current information online
- calculate: Perform mathematical calculations

## Instructions
1. Analyze the user request carefully
2. Determine if you need to use tools
3. If searching, use specific and targeted queries
4. Synthesize information from multiple sources
5. Provide a clear, structured response

## Constraints
- Never make up information
- If unsure, search first
- Keep responses concise but comprehensive
"""

# Example: Pydantic-based tool with type safety
from pydantic import BaseModel, Field
from langchain_core.tools import StructuredTool

class WeatherInput(BaseModel):
    """Input for the weather tool."""
    location: str = Field(description="City name or coordinates")
    units: str = Field(default="celsius", description="Temperature units")

def get_weather(location: str, units: str = "celsius") -> str:
    """Get current weather for a location."""
    # Implementation here
    return f"Weather in {location}: 22°{units[0].upper()}"

weather_tool = StructuredTool.from_function(
    func=get_weather,
    name="get_weather",
    description="Get current weather conditions for any location",
    args_schema=WeatherInput
)