How to Build AI Agents with LangChain API: A Comprehensive Guide

Author: Priya Sharma – API Architect and AI Integration Consultant

The ability to create intelligent systems that can understand instructions, reason, and act autonomously is transforming how we interact with technology. At the heart of this transformation are AI agents – software entities designed to perform tasks by using the power of Large Language Models (LLMs) and external tools. While the concept might sound complex, frameworks like LangChain have significantly simplified the development process, making agent creation accessible to a wider audience.

As an API architect and AI integration consultant, I’ve seen firsthand the incredible potential of well-designed AI agents. They can automate complex workflows, provide personalized assistance, and unlock new capabilities for businesses and individuals alike. This practical guide will walk you through the process of building solid AI agents using the LangChain API, from understanding the core components to implementing practical, real-world examples. By the end, you’ll have a solid foundation to design and deploy your own intelligent agents, ready to tackle a multitude of challenges.

Understanding AI Agents and LangChain’s Role

Before we explore the code, let’s clarify what an AI agent is and why LangChain is an indispensable tool for their construction. An AI agent is a system that uses an LLM as its “brain” to decide which actions to take. Unlike a simple LLM call that generates a single response, an agent can engage in a multi-step reasoning process:

• Perceive: Understand the user’s input or the current state.
• Reason: Determine the best course of action based on its understanding and available tools.
• Act: Execute one or more actions using external tools.
• Learn (optional but powerful): Incorporate feedback to improve future performance.

LangChain provides the scaffolding necessary to build these sophisticated agents. It offers a structured way to connect LLMs with various data sources and computational tools, enabling them to go beyond simple text generation. Think of LangChain as the operating system for your AI agent, providing the framework for its intelligence, memory, and ability to interact with the world.

Key Components of a LangChain Agent

To build an agent with LangChain, you’ll primarily work with these core components:

• Large Language Model (LLM): The intelligence core. This could be OpenAI’s GPT models, Anthropic’s Claude, or open-source alternatives. The LLM processes inputs, reasons, and outputs decisions.
• Tools: Functions the agent can call to interact with external systems or perform specific computations. Examples include searching the web, querying a database, calling a calculator, or interacting with a custom API.
• Toolkits: Collections of related tools designed for specific use cases (e.g., a “Wikipedia toolkit” or a “CSV agent toolkit”).
• Agent Executor: The runtime that orchestrates the agent’s actions. It takes the LLM’s decisions, executes the chosen tools, and feeds the results back to the LLM for further reasoning.
• Memory: Allows the agent to retain information from previous interactions, enabling coherent multi-turn conversations and context-aware decision-making.
• Prompt Templates: Define how user input and other information are formatted for the LLM, guiding its reasoning process.

Setting Up Your Environment and First Steps

Before writing any agent code, ensure your Python environment is ready. You’ll need Python 3.8+ and the LangChain library, along with any LLM providers you intend to use.

Installation

Install LangChain and an LLM provider (e.g., OpenAI):

pip install langchain langchain-openai
pip install python-dotenv # For managing API keys securely

Securely manage your API keys. Create a .env file in your project root:

OPENAI_API_KEY="your_openai_api_key_here"

Then, load it in your Python script:

import os
from dotenv import load_dotenv

load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

Basic LLM Interaction

To confirm your setup, let’s make a simple LLM call:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o", temperature=0) # Using a powerful model with deterministic output

messages = [
 HumanMessage(content="What is the capital of France?")
]

response = llm.invoke(messages)
print(response.content)

This basic interaction confirms that your LLM connection is working. Now, let’s enable our LLM with tools.

Crafting Tools for Your AI Agent

Tools are the agent’s hands and feet, allowing it to interact with the outside world. LangChain makes defining tools straightforward. Each tool should have a clear name, a description, and a function that performs the action.

Example: A Simple Calculator Tool

Let’s create a tool that can perform basic arithmetic. While LLMs can do simple math, external tools are more reliable for complex calculations.

from langchain.tools import tool

@tool
def calculator(expression: str) -> str:
 """Evaluates a mathematical expression and returns the result.
 Input should be a string containing a valid mathematical expression, e.g., '2 + 2' or '(5 * 3) / 2'.
 """
 try:
 return str(eval(expression))
 except Exception as e:
 return f"Error evaluating expression: {e}"

# You can test the tool directly
print(calculator.invoke("10 * 5 + 3"))

Notice the @tool decorator. This automatically converts your function into a LangChain tool. The docstring is crucial as it serves as the tool’s description, which the LLM uses to understand when and how to use it.

Example: A Web Search Tool (Using Tavily)

Most powerful agents need access to up-to-date information. A web search tool is fundamental. We’ll use Tavily, a search API specifically designed for RAG (Retrieval Augmented Generation) and agent use cases.

First, install Tavily and set your API key in your .env file:

pip install tavily-python

TAVILY_API_KEY="your_tavily_api_key_here"

Then, load it:

import os
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults

load_dotenv()
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")

# Create the Tavily search tool
search = TavilySearchResults(max_results=3) # Get top 3 results
# You can also customize the name and description if needed
# search.name = "web_search"
# search.description = "Searches the web for information."

# Test the search tool
print(search.invoke("LangChain agent tutorial"))

By defining these tools, we’re giving our agent the capabilities it needs to extend its knowledge beyond its training data and perform computations accurately.

Building Your First LangChain Agent

With our LLM and tools ready, we can now assemble our first LangChain agent. We’ll use the “create_openai_functions_agent” method, which is a convenient way to build agents that use OpenAI’s function calling capabilities.

Agent Construction Steps

1. Define your LLM: The brain of your agent.
2. Define your Tools: The capabilities your agent possesses.
3. Create a Prompt Template: Guide the LLM on how to behave.
4. Create the Agent: Combine LLM, tools, and prompt.
5. Create the Agent Executor: The runtime that executes the agent’s decisions.

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults

# Load environment variables
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")

# 1. Define LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 2. Define Tools
@tool
def calculator(expression: str) -> str:
 """Evaluates a mathematical expression and returns the result.
 Input should be a string containing a valid mathematical expression, e.g., '2 + 2' or '(5 * 3) / 2'.
 """
 try:
 return str(eval(expression))
 except Exception as e:
 return f"Error evaluating expression: {e}"

search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Searches the web for current information on a given query."

tools = [calculator, search]

# 3. Create a Prompt Template
prompt = ChatPromptTemplate.from_messages(
 [
 ("system", "You are a helpful AI assistant. Answer questions as accurately as possible."),
 MessagesPlaceholder(variable_name="chat_history"),
 ("human", "{input}"),
 MessagesPlaceholder(variable_name="agent_scratchpad"),
 ]
)

# 4. Create the Agent
agent = create_openai_functions_agent(llm, tools, prompt)

# 5. Create the Agent Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run the agent
# print("--- Agent Run 1 (Simple Calculation) ---")
# result1 = agent_executor.invoke({"input": "What is 12345 * 6789?", "chat_history": []})
# print(result1["output"])

# print("\n--- Agent Run 2 (Web Search) ---")
# result2 = agent_executor.invoke({"input": "What is the capital of Portugal and what is its current population?", "chat_history": []})
# print(result2["output"])

# print("\n--- Agent Run 3 (Combined) ---")
# result3 = agent_executor.invoke({"input": "What is the square root of 81 and who invented the World Wide Web?", "chat_history": []})
# print(result3["output"])

When you set verbose=True in the AgentExecutor, you’ll see the agent’s thought process: which tools it considers, which it selects, the input it provides to the tool, and the tool’s output. This is incredibly useful for debugging and understanding how your agent reasons.

Understanding the Prompt Template

• system: Sets the overall persona and instructions for the agent.
• MessagesPlaceholder(variable_name="chat_history"): This is where previous conversation turns will be inserted, enabling memory.
• human: The current user input.
• MessagesPlaceholder(variable_name="agent_scratchpad"): This is where the agent’s internal thought process and tool outputs are stored during a single invocation, allowing the LLM to reason step-by-step.

Adding Memory and State to Your AI Agent

A truly intelligent agent needs memory to maintain context across multiple turns of a conversation. LangChain provides various memory types, allowing your agent to remember past interactions.

Why Memory is Important

• Coherence: Agents can refer to previous statements and questions.
• Personalization: Agents can remember user preferences or past interactions.
• Efficiency: Avoids repeating information or asking for clarification on already provided details.

Implementing ConversationBufferMemory

ConversationBufferMemory is a simple yet effective memory type that stores all previous messages directly.

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory # Import memory

# Load environment variables
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")

# LLM and Tools (same as before)
llm = ChatOpenAI(model="gpt-4o", temperature=0)

@tool
def calculator(expression: str) -> str:
 """Evaluates a mathematical expression and returns the result.
 Input should be a string containing a valid mathematical expression, e.g., '2 + 2' or '(5 * 3) / 2'.
 """
 try:
 return str(eval(expression))
 except Exception as e:
 return f"Error evaluating expression: {e}"

search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Searches the web for current information on a given query."

tools = [calculator, search]

# Create a Prompt Template (note the `chat_history` placeholder)
prompt = ChatPromptTemplate.from_messages(
 [
 ("system", "You are a helpful AI assistant. Remember previous interactions and answer questions as accurately as possible."),
 MessagesPlaceholder(variable_name="chat_history"), # This is where memory will be injected
 ("human", "{input}"),
 MessagesPlaceholder(variable_name="agent_scratchpad"),
 ]
)

# Initialize memory
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# Create the Agent
agent = create_openai_functions_agent(llm, tools, prompt)

# Create the Agent Executor, passing in the memory
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)

# Run the agent with memory
print("--- Agent Run with Memory ---")
print("\nUser: What is the capital of Spain?")
result1 = agent_executor.invoke({"input": "What is the capital of Spain?"})
print("Agent:", result1["output"])

print("\nUser: What is its population?")
result2 = agent_executor.invoke({"input": "What is its population?"})
print("Agent:", result2["output"])

print("\nUser: And what about the population of France's capital?")
result3 = agent_executor.invoke({"input": "And what about the population of France's capital?"})
print("Agent:", result3["output"])

In this example, the agent remembers “Spain” from the first turn, and “France’s capital” from the third, allowing it to provide relevant answers without needing explicit re-statement of the country. The memory_key="chat_history" ensures that the memory content is correctly mapped to the MessagesPlaceholder(variable_name="chat_history") in our prompt.

Other Memory Types

Related Articles

• Getting to the Heart of Effective API Design Patterns
• AI agent streaming APIs
• Qdrant vs FAISS: Which One for Startups

🕒 Last updated: March 26, 2026  ·  Originally published: March 17, 2026