# Define tools using LangChain's Tool wrapper tools = [ Tool( name="calculator", func=calculator, description="Evaluate mathematical expressions. Input should be a valid math expression." ), Tool( name="web_search", func=web_search, description="Search the web for current information. Use for facts, news, weather, and real-time data." ) ]

# Create the prompt template prompt = ChatPromptTemplate.from_messages([ ("system", """You are a helpful AI assistant. Use the available tools to answer questions. Think step by step:

1. What information do I need?
2. Which tool can provide that information?
3. What parameters does the tool need?
4. After getting the result, do I need to do more, or can I answer?"""),

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

# Create the agent agent = create_tool_calling_agent(llm, tools, prompt)

# Create the executor agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, max_iterations=10, handle_parsing_errors=True )

# Run the agent result = agent_executor.invoke({ "input": "What is 15% of 240, and what is the square root of that?" })

Adding Memory and Context

A key feature of agents is the ability to remember previous interactions. Let's add memory to our agent.

# Create memory that stores the full conversation memory = ConversationBufferMemory( memory_key="chat_history", return_messages=True )

# Create agent with memory agent_executor = AgentExecutor( agent=agent, tools=tools, memory=memory, verbose=True, max_iterations=10 )

# First interaction result1 = agent_executor.invoke({ "input": "My name is Alice and I live in New York." }) print(f"Agent: {result1['output']}")

Working with Tools and Functions

Tools are what make agents powerful. Let's build a thorough set of tools.

class FileReadInput(BaseModel): filepath: str = Field(description="Path to the file to read")

class FileWriteInput(BaseModel): filepath: str = Field(description="Path to the file to write") content: str = Field(description="Content to write to the file")

@tool(args_schema=FileReadInput) def read_file(filepath: str) -> str: """Read the contents of a file.""" try: with open(filepath, 'r', encoding='utf-8') as f: return f.read() except FileNotFoundError: return f"Error: File '{filepath}' not found" except Exception as e: return f"Error: {e}"

@tool def get_weather(city: str) -> str: """Get the current weather for a city using OpenWeatherMap API.""" api_key = os.getenv("OPENWEATHER_API_KEY") url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric" try: response = requests.get(url) data = response.json() if response.status_code == 200: temp = data["main"]["temp"] description = data["weather"][0]["description"] humidity = data["main"]["humidity"] return f"Weather in {city}: {description}, {temp}°C, humidity {humidity}%" else: return f"Error: {data.get('message', 'Unknown error')}" except Exception as e: return f"Error fetching weather: {e}"

# Create the agent with all tools prompt = ChatPromptTemplate.from_messages([ ("system", """You are a powerful AI assistant with access to multiple tools.

Available tools:

• calculator: For mathematical calculations
• web_search: For searching the internet
• get_weather: For weather information
• fetch_url: For reading web pages
• read_file: For reading local files
• write_file: For writing to local files
• query_database: For querying the SQLite database

Think step by step. Break complex tasks into smaller steps. Always verify your work before giving a final answer."""), MessagesPlaceholder(variable_name="chat_history", optional=True), ("human", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad") ])

Real-World Examples

Let's build three complete, real-world agent applications.

from langchain_openai import ChatOpenAI from langchain.agents import create_tool_calling_agent, AgentExecutor from langchain_core.tools import Tool from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain.memory import ConversationBufferMemory import requests from bs4 import BeautifulSoup

def search_google(query: str, num_results: int = 5) -> str: """Search Google using SerpAPI.""" api_key = os.getenv("SERPAPI_KEY") url = "https://serpapi.com/search" params = { "q": query, "api_key": api_key, "num": num_results } try: response = requests.get(url, params=params) data = response.json() results = data.get("organic_results", []) output = "" for i, result in enumerate(results, 1): output += f"{i}. {result['title']}\n" output += f" {result['link']}\n" output += f" {result.get('snippet', 'No snippet')}\n\n" return output if results else "No results found." except Exception as e: return f"Search error: {e}"

def read_article(url: str) -> str: """Read and extract the main text from a web article.""" try: response = requests.get(url, timeout=15) soup = BeautifulSoup(response.text, 'html.parser') # Remove script and style elements for element in soup(["script", "style", "nav", "header", "footer"]): element.decompose() # Get main content article = soup.find("article") or soup.find("main") or soup.find("body") text = article.get_text(separator="\n", strip=True) # Clean up whitespace lines = [line.strip() for line in text.splitlines() if line.strip()] clean_text = "\n".join(lines) return clean_text[:8000] # Limit to 8000 chars except Exception as e: return f"Error reading article: {e}"

# Define research tools research_tools = [ Tool(name="search_google", func=search_google, description="Search Google for information"), Tool(name="read_article", func=read_article, description="Read and extract text from a web article URL"), Tool(name="calculator", func=calculator, description="Perform mathematical calculations") ]

# Research agent prompt research_prompt = ChatPromptTemplate.from_messages([ ("system", """You are an expert research assistant. Your job is to:

1. Search for relevant information using web search
2. Read the most promising articles in detail
3. Synthesize the information into a thorough report
4. Cite your sources

Format your reports with:

• Executive Summary
• Key Findings (with source citations)
• Analysis
• Recommendations

Always search for multiple perspectives and verify claims across sources."""), MessagesPlaceholder(variable_name="chat_history", optional=True), ("human", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad") ])

# Create the research agent llm = ChatOpenAI(model="gpt-4o", temperature=0.3) research_agent = create_tool_calling_agent(llm, research_tools, research_prompt) research_executor = AgentExecutor( agent=research_agent, tools=research_tools, verbose=True, max_iterations=15 )

# Run a research task result = research_executor.invoke({ "input": "Research the current state of AI agent frameworks in 2025. Compare LangChain, AutoGen, CrewAI, and LangGraph." })

import pandas as pd import matplotlib.pyplot as plt import io import base64

@tool def load_csv(filepath: str) -> str: """Load a CSV file and return a summary of its contents.""" try: df = pd.read_csv(filepath) summary = f"File: {filepath}\n" summary += f"Shape: {df.shape[0]} rows × {df.shape[1]} columns\n" summary += f"Columns: {', '.join(df.columns.tolist())}\n" summary += f"Data types:\n{df.dtypes.to_string()}\n" summary += f"\nFirst 5 rows:\n{df.head().to_string()}\n" summary += f"\nBasic statistics:\n{df.describe().to_string()}\n" return summary except Exception as e: return f"Error loading CSV: {e}"

@tool def analyze_data(query: str) -> str: """Analyze the loaded data. The query describes what analysis to perform. Available data is in the pandas DataFrame 'df'.""" try: # This is a simplified version. in production, use a code execution sandbox # The agent would generate and execute pandas code return f"Analysis result for: {query}" except Exception as e: return f"Analysis error: {e}"

@tool def create_chart(chart_type: str, x_column: str, y_column: str, title: str) -> str: """Create a chart from the loaded data. chart_type can be 'bar', 'line', 'scatter', or 'histogram'.""" try: df = pd.read_csv("temp_data.csv") # Assume data was saved temporarily plt.figure(figsize=(10, 6)) if chart_type == "bar": df.plot.bar(x=x_column, y=y_column) elif chart_type == "line": df.plot.line(x=x_column, y=y_column) elif chart_type == "scatter": df.plot.scatter(x=x_column, y=y_column) elif chart_type == "histogram": df[x_column].plot.hist() plt.title(title) plt.tight_layout() # Save to base64 string buffer = io.BytesIO() plt.savefig(buffer, format='png') buffer.seek(0) image_base64 = base64.b64encode(buffer.read()).decode() plt.close() return f"Chart created successfully. Base64: {image_base64[:100]}..." except Exception as e: return f"Chart error: {e}"

data_tools = [load_csv, analyze_data, create_chart]

data_prompt = ChatPromptTemplate.from_messages([ ("system", """You are a data analysis expert. You can:

• Load CSV files and examine their structure
• Perform statistical analysis and data transformations
• Create visualizations (bar charts, line plots, scatter plots, histograms)
• Generate insights and recommendations based on the data

Always start by loading and understanding the data before analyzing."""), ("human", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad") ])

@tool def lookup_order(order_id: str) -> str: """Look up an order by ID and return order details.""" # In production, this would query your database orders_db = { "ORD-001": {"status": "shipped", "item": "Wireless Headphones", "price": 79.99, "tracking": "1Z999AA10123456784"}, "ORD-002": {"status": "processing", "item": "USB-C Hub", "price": 45.99, "tracking": None}, "ORD-003": {"status": "delivered", "item": "Mechanical Keyboard", "price": 129.99, "tracking": "1Z999AA10123456785"}, } order = orders_db.get(order_id) if order: return json.dumps(order, indent=2) return f"Order {order_id} not found."

Deploying with Render

Now that our agent works locally, let's deploy it to the cloud using Render so anyone can access it via an API.

app = FastAPI( title="AI Agent API", description="A powerful AI agent with tool-calling capabilities", version="1.0.0" )

class AgentRequest(BaseModel): message: str session_id: Optional[str] = "default"

class AgentResponse(BaseModel): response: str session_id: str

@app.post("/chat", response_model=AgentResponse) async def chat(request: AgentRequest): """Send a message to the AI agent and get a response.""" try: result = agent_executor.invoke({ "input": request.message }) return AgentResponse( response=result["output"], session_id=request.session_id ) except Exception as e: raise HTTPException(status_code=500, detail=str(e))

@app.get("/health") async def health_check(): """Health check endpoint.""" return {"status": "healthy", "service": "ai-agent-api"}