Tools: Building Your Own AI Agent: A Practical Guide with LangGraph

From Chatbots to Autonomous Agents: The Next AI Frontier ## What Makes an Agent Different? ## Setting Up Your Development Environment ## Building Your First Agent: The Research Assistant ## Step 1: Define the Tools ## Step 2: Create the Agent State ## Step 3: Build the Agent Graph ## Step 4: Run Your Agent ## Advanced Agent Patterns ## Multi-Agent Systems ## Memory and Learning ## Best Practices for Production Agents ## The Future is Agentic ## Your Next Steps We've all interacted with AI chatbots. You ask a question, you get an answer. It's useful, but fundamentally reactive. The real frontier in AI isn't about better question-answering—it's about creating systems that can act autonomously. Imagine an AI that doesn't just tell you the weather, but checks your calendar, sees you have an outdoor meeting, and messages you to bring an umbrella. That's the promise of AI agents. While enterprise MCP gateways represent one approach to structured AI workflows, this guide will take you through building your own autonomous agent from scratch using LangGraph. You'll create an agent that can research topics, write summaries, and even execute simple tasks—all without constant human prompting. Before we dive into code, let's clarify terminology. An AI agent has three key characteristics that distinguish it from a simple chatbot: Think of it this way: a chatbot answers questions; an agent accomplishes tasks. Let's start by setting up our workspace. We'll use LangChain and LangGraph, two powerful frameworks for building agentic systems. You'll also need an OpenAI API key (or another LLM provider): Let's create a practical agent that can research any topic and provide a comprehensive summary. We'll build this step by step. Tools are what give your agent superpowers. Here are three essential tools for our research agent: LangGraph uses a stateful approach. Let's define what information our agent needs to track: This is where the magic happens. We'll create a graph that defines how our agent thinks and acts: Now let's put our agent to work: Once you have the basics working, you can implement more sophisticated patterns: Create specialized agents that work together: Add memory to your agent so it learns from previous interactions: Building agents for production requires additional considerations: The shift from chatbots to agents represents a fundamental change in how we interact with AI. Instead of asking for information, we'll be delegating tasks. Instead of getting answers, we'll be receiving completed work. What we've built today is just the beginning. As agent frameworks mature and LLMs become more capable, we'll see agents that can: The most exciting part? You don't need to wait. The tools to build autonomous agents are available today. Start small with a research assistant, then expand to more complex workflows. The agents you build now will be the foundation for the AI-powered future. The best way to learn is by doing. Clone the code from this article, modify it for your needs, and share what you build. What task will you automate first? Want to dive deeper? Check out the LangGraph documentation for more advanced patterns and examples. Have questions or want to share your agent creations? Leave a comment below! Templates let you quickly answer FAQs or store snippets for re-use. Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink. Hide child comments as well For further actions, you may consider blocking this person and/or reporting abuse COMMAND_BLOCK: pip install langchain langgraph langchain-openai Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: pip install langchain langgraph langchain-openai COMMAND_BLOCK: pip install langchain langgraph langchain-openai CODE_BLOCK: import os from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = "your-api-key-here" llm = ChatOpenAI(model="gpt-4-turbo") Enter fullscreen mode Exit fullscreen mode CODE_BLOCK: import os from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = "your-api-key-here" llm = ChatOpenAI(model="gpt-4-turbo") CODE_BLOCK: import os from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = "your-api-key-here" llm = ChatOpenAI(model="gpt-4-turbo") COMMAND_BLOCK: from langchain.tools import Tool from langchain_community.utilities import DuckDuckGoSearchAPIWrapper from datetime import datetime # Web search tool search = DuckDuckGoSearchAPIWrapper() search_tool = Tool( name="web_search", func=search.run, description="Search the web for current information" ) # Calculator tool (for processing numerical data) def calculator(expression: str) -> str: """Evaluate a mathematical expression.""" try: return str(eval(expression)) except: return "Error evaluating expression" calc_tool = Tool( name="calculator", func=calculator, description="Perform calculations" ) # Current time tool def get_current_time(_=None) -> str: return datetime.now().strftime("%Y-%m-%d %H:%M:%S") time_tool = Tool( name="current_time", func=get_current_time, description="Get the current date and time" ) tools = [search_tool, calc_tool, time_tool] Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: from langchain.tools import Tool from langchain_community.utilities import DuckDuckGoSearchAPIWrapper from datetime import datetime # Web search tool search = DuckDuckGoSearchAPIWrapper() search_tool = Tool( name="web_search", func=search.run, description="Search the web for current information" ) # Calculator tool (for processing numerical data) def calculator(expression: str) -> str: """Evaluate a mathematical expression.""" try: return str(eval(expression)) except: return "Error evaluating expression" calc_tool = Tool( name="calculator", func=calculator, description="Perform calculations" ) # Current time tool def get_current_time(_=None) -> str: return datetime.now().strftime("%Y-%m-%d %H:%M:%S") time_tool = Tool( name="current_time", func=get_current_time, description="Get the current date and time" ) tools = [search_tool, calc_tool, time_tool] COMMAND_BLOCK: from langchain.tools import Tool from langchain_community.utilities import DuckDuckGoSearchAPIWrapper from datetime import datetime # Web search tool search = DuckDuckGoSearchAPIWrapper() search_tool = Tool( name="web_search", func=search.run, description="Search the web for current information" ) # Calculator tool (for processing numerical data) def calculator(expression: str) -> str: """Evaluate a mathematical expression.""" try: return str(eval(expression)) except: return "Error evaluating expression" calc_tool = Tool( name="calculator", func=calculator, description="Perform calculations" ) # Current time tool def get_current_time(_=None) -> str: return datetime.now().strftime("%Y-%m-%d %H:%M:%S") time_tool = Tool( name="current_time", func=get_current_time, description="Get the current date and time" ) tools = [search_tool, calc_tool, time_tool] COMMAND_BLOCK: from typing import TypedDict, List, Annotated import operator class AgentState(TypedDict): """State of our research agent.""" task: str # The original research task steps: List[str] # Steps taken so far findings: List[str] # Research findings current_step: str # What we're currently doing iterations: int # How many steps we've taken Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: from typing import TypedDict, List, Annotated import operator class AgentState(TypedDict): """State of our research agent.""" task: str # The original research task steps: List[str] # Steps taken so far findings: List[str] # Research findings current_step: str # What we're currently doing iterations: int # How many steps we've taken COMMAND_BLOCK: from typing import TypedDict, List, Annotated import operator class AgentState(TypedDict): """State of our research agent.""" task: str # The original research task steps: List[str] # Steps taken so far findings: List[str] # Research findings current_step: str # What we're currently doing iterations: int # How many steps we've taken COMMAND_BLOCK: from langgraph.graph import StateGraph, END from langchain.agents import create_react_agent from langchain.agents.output_parsers import ReActSingleInputOutputParser # Create the agent agent_executor = create_react_agent(llm, tools, ReActSingleInputOutputParser()) def research_node(state: AgentState) -> dict: """Node that performs research steps.""" # Format the prompt based on our state prompt = f""" Task: {state['task']} Steps taken so far: {state['steps'][-3:] if state['steps'] else 'None'} Current findings: {state['findings'][-2:] if state['findings'] else 'None'} What should be the next research step? Be specific about what to search for or calculate. """ # Get the agent's decision response = agent_executor.invoke({"input": prompt}) # Execute the action if it involves a tool action = response["output"] # Update state new_state = state.copy() new_state["steps"].append(action) new_state["iterations"] += 1 # Check if we should continue if "FINAL ANSWER" in action or new_state["iterations"] >= 5: new_state["current_step"] = "complete" else: new_state["current_step"] = "continue_research" return new_state def summarize_node(state: AgentState) -> dict: """Node that summarizes findings.""" summary_prompt = f""" Based on these research findings: {chr(10).join(state['findings'])} Provide a comprehensive summary of the topic: {state['task']} """ summary = llm.invoke(summary_prompt) new_state = state.copy() new_state["findings"].append(f"SUMMARY: {summary.content}") new_state["current_step"] = "end" return new_state # Build the graph workflow = StateGraph(AgentState) # Add nodes workflow.add_node("research", research_node) workflow.add_node("summarize", summarize_node) # Define the flow workflow.set_entry_point("research") # Add conditional edges def decide_next_step(state: AgentState) -> str: if state["current_step"] == "complete": return "summarize" elif state["iterations"] >= 5: return "summarize" else: return "research" workflow.add_conditional_edges( "research", decide_next_step, { "research": "research", "summarize": "summarize" } ) workflow.add_edge("summarize", END) # Compile the graph agent = workflow.compile() Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: from langgraph.graph import StateGraph, END from langchain.agents import create_react_agent from langchain.agents.output_parsers import ReActSingleInputOutputParser # Create the agent agent_executor = create_react_agent(llm, tools, ReActSingleInputOutputParser()) def research_node(state: AgentState) -> dict: """Node that performs research steps.""" # Format the prompt based on our state prompt = f""" Task: {state['task']} Steps taken so far: {state['steps'][-3:] if state['steps'] else 'None'} Current findings: {state['findings'][-2:] if state['findings'] else 'None'} What should be the next research step? Be specific about what to search for or calculate. """ # Get the agent's decision response = agent_executor.invoke({"input": prompt}) # Execute the action if it involves a tool action = response["output"] # Update state new_state = state.copy() new_state["steps"].append(action) new_state["iterations"] += 1 # Check if we should continue if "FINAL ANSWER" in action or new_state["iterations"] >= 5: new_state["current_step"] = "complete" else: new_state["current_step"] = "continue_research" return new_state def summarize_node(state: AgentState) -> dict: """Node that summarizes findings.""" summary_prompt = f""" Based on these research findings: {chr(10).join(state['findings'])} Provide a comprehensive summary of the topic: {state['task']} """ summary = llm.invoke(summary_prompt) new_state = state.copy() new_state["findings"].append(f"SUMMARY: {summary.content}") new_state["current_step"] = "end" return new_state # Build the graph workflow = StateGraph(AgentState) # Add nodes workflow.add_node("research", research_node) workflow.add_node("summarize", summarize_node) # Define the flow workflow.set_entry_point("research") # Add conditional edges def decide_next_step(state: AgentState) -> str: if state["current_step"] == "complete": return "summarize" elif state["iterations"] >= 5: return "summarize" else: return "research" workflow.add_conditional_edges( "research", decide_next_step, { "research": "research", "summarize": "summarize" } ) workflow.add_edge("summarize", END) # Compile the graph agent = workflow.compile() COMMAND_BLOCK: from langgraph.graph import StateGraph, END from langchain.agents import create_react_agent from langchain.agents.output_parsers import ReActSingleInputOutputParser # Create the agent agent_executor = create_react_agent(llm, tools, ReActSingleInputOutputParser()) def research_node(state: AgentState) -> dict: """Node that performs research steps.""" # Format the prompt based on our state prompt = f""" Task: {state['task']} Steps taken so far: {state['steps'][-3:] if state['steps'] else 'None'} Current findings: {state['findings'][-2:] if state['findings'] else 'None'} What should be the next research step? Be specific about what to search for or calculate. """ # Get the agent's decision response = agent_executor.invoke({"input": prompt}) # Execute the action if it involves a tool action = response["output"] # Update state new_state = state.copy() new_state["steps"].append(action) new_state["iterations"] += 1 # Check if we should continue if "FINAL ANSWER" in action or new_state["iterations"] >= 5: new_state["current_step"] = "complete" else: new_state["current_step"] = "continue_research" return new_state def summarize_node(state: AgentState) -> dict: """Node that summarizes findings.""" summary_prompt = f""" Based on these research findings: {chr(10).join(state['findings'])} Provide a comprehensive summary of the topic: {state['task']} """ summary = llm.invoke(summary_prompt) new_state = state.copy() new_state["findings"].append(f"SUMMARY: {summary.content}") new_state["current_step"] = "end" return new_state # Build the graph workflow = StateGraph(AgentState) # Add nodes workflow.add_node("research", research_node) workflow.add_node("summarize", summarize_node) # Define the flow workflow.set_entry_point("research") # Add conditional edges def decide_next_step(state: AgentState) -> str: if state["current_step"] == "complete": return "summarize" elif state["iterations"] >= 5: return "summarize" else: return "research" workflow.add_conditional_edges( "research", decide_next_step, { "research": "research", "summarize": "summarize" } ) workflow.add_edge("summarize", END) # Compile the graph agent = workflow.compile() COMMAND_BLOCK: # Initialize the state initial_state = AgentState( task="Research the impact of AI on software development jobs in 2024", steps=[], findings=[], current_step="start", iterations=0 ) # Run the agent result = agent.invoke(initial_state) print("=== RESEARCH COMPLETE ===") print(f"Task: {result['task']}") print(f"Steps taken: {len(result['steps'])}") print("\n=== SUMMARY ===") print(result['findings'][-1]) # The final summary Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: # Initialize the state initial_state = AgentState( task="Research the impact of AI on software development jobs in 2024", steps=[], findings=[], current_step="start", iterations=0 ) # Run the agent result = agent.invoke(initial_state) print("=== RESEARCH COMPLETE ===") print(f"Task: {result['task']}") print(f"Steps taken: {len(result['steps'])}") print("\n=== SUMMARY ===") print(result['findings'][-1]) # The final summary COMMAND_BLOCK: # Initialize the state initial_state = AgentState( task="Research the impact of AI on software development jobs in 2024", steps=[], findings=[], current_step="start", iterations=0 ) # Run the agent result = agent.invoke(initial_state) print("=== RESEARCH COMPLETE ===") print(f"Task: {result['task']}") print(f"Steps taken: {len(result['steps'])}") print("\n=== SUMMARY ===") print(result['findings'][-1]) # The final summary COMMAND_BLOCK: class MultiAgentSystem: def __init__(self): self.researcher = create_research_agent() self.analyst = create_analysis_agent() self.writer = create_writing_agent() def execute_complex_task(self, task: str): # Researcher gathers information research_data = self.researcher.research(task) # Analyst processes and analyzes insights = self.analyst.analyze(research_data) # Writer creates final output return self.writer.write_report(insights) Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: class MultiAgentSystem: def __init__(self): self.researcher = create_research_agent() self.analyst = create_analysis_agent() self.writer = create_writing_agent() def execute_complex_task(self, task: str): # Researcher gathers information research_data = self.researcher.research(task) # Analyst processes and analyzes insights = self.analyst.analyze(research_data) # Writer creates final output return self.writer.write_report(insights) COMMAND_BLOCK: class MultiAgentSystem: def __init__(self): self.researcher = create_research_agent() self.analyst = create_analysis_agent() self.writer = create_writing_agent() def execute_complex_task(self, task: str): # Researcher gathers information research_data = self.researcher.research(task) # Analyst processes and analyzes insights = self.analyst.analyze(research_data) # Writer creates final output return self.writer.write_report(insights) COMMAND_BLOCK: from langchain.memory import ConversationBufferMemory class LearningAgent: def __init__(self): self.memory = ConversationBufferMemory( return_messages=True, memory_key="chat_history" ) self.past_tasks = [] def execute_with_memory(self, task: str): # Check if we've done similar tasks before similar_tasks = self.find_similar_tasks(task) # Incorporate past learning context = f"Previously, we learned: {similar_tasks}" # Execute with context return self.agent.execute(task, context) Enter fullscreen mode Exit fullscreen mode COMMAND_BLOCK: from langchain.memory import ConversationBufferMemory class LearningAgent: def __init__(self): self.memory = ConversationBufferMemory( return_messages=True, memory_key="chat_history" ) self.past_tasks = [] def execute_with_memory(self, task: str): # Check if we've done similar tasks before similar_tasks = self.find_similar_tasks(task) # Incorporate past learning context = f"Previously, we learned: {similar_tasks}" # Execute with context return self.agent.execute(task, context) COMMAND_BLOCK: from langchain.memory import ConversationBufferMemory class LearningAgent: def __init__(self): self.memory = ConversationBufferMemory( return_messages=True, memory_key="chat_history" ) self.past_tasks = [] def execute_with_memory(self, task: str): # Check if we've done similar tasks before similar_tasks = self.find_similar_tasks(task) # Incorporate past learning context = f"Previously, we learned: {similar_tasks}" # Execute with context return self.agent.execute(task, context) CODE_BLOCK: class SafeAgent: def __init__(self): self.safety_checks = [ self.check_for_harmful_content, self.validate_tool_usage, self.monitor_resource_usage ] def safe_execute(self, task: str): for check in self.safety_checks: if not check(task): raise SecurityError(f"Safety check failed: {check.__name__}") return self.agent.execute(task) Enter fullscreen mode Exit fullscreen mode CODE_BLOCK: class SafeAgent: def __init__(self): self.safety_checks = [ self.check_for_harmful_content, self.validate_tool_usage, self.monitor_resource_usage ] def safe_execute(self, task: str): for check in self.safety_checks: if not check(task): raise SecurityError(f"Safety check failed: {check.__name__}") return self.agent.execute(task) CODE_BLOCK: class SafeAgent: def __init__(self): self.safety_checks = [ self.check_for_harmful_content, self.validate_tool_usage, self.monitor_resource_usage ] def safe_execute(self, task: str): for check in self.safety_checks: if not check(task): raise SecurityError(f"Safety check failed: {check.__name__}") return self.agent.execute(task) - Goal-oriented: It works toward a specific objective - Autonomous: It can make decisions about what steps to take - Tool-using: It can interact with external systems and APIs - Error Handling: Always wrap tool calls in try-except blocks - Rate Limiting: Implement backoff strategies for API calls - Validation: Validate all inputs and outputs - Monitoring: Log all agent decisions and actions - Safety: Implement guardrails to prevent harmful actions - Manage entire software projects - Conduct scientific research - Run businesses - Provide personalized education - Extend the research agent with more tools (database queries, API integrations) - Build a specialized agent for your specific domain - Experiment with different architectures (hierarchical, swarm, federated) - Join the community at the LangChain Discord or LangGraph GitHub