自作人工知能代理人の実用ガイド：LangGraphで

チャットボットから自律的な代理人へ：次なるAIフロンティア 私たちは誰一人としてAIのチャットボットを使い、質問がありますと答えるのを経験しています。価値があるものですが、基本的には反応型です。AIの本格的な開発には、もっとも重要なポイントは、情報を得て作業をする能力があります。要するに、雨や傘などに関することを調べる機能です。 自律的な人工知能代理人は、私たちが期待するようなものであり、企業向けMCPゲートウェイという方法がありますが、このガイドでは、LangGraphを使って自作の自律的な代理人を作ることをあなたに助けるために構築します。その代理人はあなたの指示を求めずに情報を研究し、文章をまとめたり実行できるシンプルなタスクを行うのです。 ただし、私たちはそれが必要だと思っています：AIの本質的な特性を理解して自作する代理人にとって、言語や知識が重要です。これは、単なるチャットボットと違い、具体的な目的に向かって行動します。 代理人はまた外部システムへのインタラクションを行い、ツールを持っています。（要因にはweb検索ツール、計算機関と現時時のツールなどがあります） まずワークスペースを構築しましょう。LangChainとLangGraphという力強いフレームウェアを使用します。 pip install langchain langgraph langchain-openai あとはAPIキーが必要です（他のロングレーンプロバイダも使用できます）： from os import environ, from langchain_openai import ChatOpenAI

From Chatbots to Autonomous Agents: The Next AI Frontier 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: 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 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. pip install langchain langgraph langchain-openai You'll also need an OpenAI API key (or another LLM provider): import os from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = "your-api-key-here" llm = ChatOpenAI(model="gpt-4-turbo") 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: 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] LangGraph uses a stateful approach. Let's define what information our agent needs to track: 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 This is where the magic happens. We'll create a graph that defines how our agent thinks and acts: 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() Now let's put our agent to work: # 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 Once you have the basics working, you can implement more sophisticated patterns: Create specialized agents that work together: 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) Add memory to your agent so it learns from previous interactions: 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) Building agents for production requires additional considerations: 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 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) 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: Manage entire software projects Conduct scientific research Run businesses Provide personalized education 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. 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 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!