AI Agent 開發入門實戰 2026

AI Agent 開發入門實戰

🤖 AI Agent 是 AI 應用的下一個範式。 與傳統的"提問-回答"模式不同，Agent 能夠自主規劃任務、調用外部工具、根據反饋調整策略，完成複雜的多步驟工作。2026 年，Agent 框架已經成熟，本文帶你從零構建自己的 AI Agent。

本文將帶你係統掌握：

✅ AI Agent 核心概念與架構
✅ Agent 與普通 LLM 調用的區別
✅ 工具調用（Function Calling）原理與實戰
✅ LangChain Agent 開發
✅ 記憶系統與上下文管理
✅ RAG 檢索增強生成
✅ 多 Agent 協作
✅ 生產部署與最佳實踐

一、AI Agent 核心概念

1.1 什麼是 AI Agent

AI Agent 是一個能夠自主感知、決策和執行的智能體：

傳統 LLM：用戶提問 → LLM 回答
AI Agent：用戶目標 → 規劃任務 → 調用工具 → 觀察結果 → 調整策略 → 完成目標

Agent 的核心能力：

感知（Perception）：理解用戶意圖和環境信息
規劃（Planning）：將目標分解為可執行的步驟
執行（Action）：調用工具/API 完成具體任務
反思（Reflection）：根據執行結果調整策略

1.2 Agent vs 普通 LLM

特性	普通 LLM	AI Agent
交互模式	單輪問答	多輪自主執行
工具使用	無	可調用外部 API
記憶	僅當前上下文	短期+長期記憶
規劃能力	無	自動分解任務
錯誤處理	無法重試	自動調整重試
適用場景	簡單問答	複雜多步任務

1.3 Agent 架構

┌─────────────────────────────────────┐
│            AI Agent                 │
│  ┌───────────┐  ┌───────────────┐  │
│  │  LLM 大腦 │  │   記憶系統    │  │
│  └─────┬─────┘  └───────┬───────┘  │
│        │                │          │
│  ┌─────▼─────────────────▼───────┐  │
│  │        規劃與決策引擎        │  │
│  └─────┬─────────────────┬───────┘  │
│        │                │          │
│  ┌─────▼─────┐  ┌───────▼───────┐  │
│  │  工具調用  │  │  觀察與反思  │  │
│  └───────────┘  └───────────────┘  │
└─────────────────────────────────────┘
         │
┌────────▼────────────────────────────┐
│          外部工具 / API             │
│  搜索 │ 數據庫 │ 文件 │ 代碼執行   │
└─────────────────────────────────────┘

二、環境準備

2.1 安裝依賴

bash

# 創建項目
mkdir ai-agent-demo && cd ai-agent-demo
python -m venv venv
source venv/bin/activate

# 安裝 LangChain
pip install langchain langchain-openai langchain-community

# 安裝 LlamaIndex
pip install llama-index llama-index-llms-openai

# 安裝工具依賴
pip install wikipedia duckduckgo-search

2.2 配置 API Key

bash

# 設置環境變量
export OPENAI_API_KEY="sk-xxx"

# 或使用 .env 文件
echo 'OPENAI_API_KEY=sk-xxx' > .env

💡 也可以使用其他模型提供商：Anthropic、DeepSeek、本地 Ollama 等。

三、工具調用（Function Calling）

3.1 什麼是工具調用

工具調用讓 LLM 能夠"使用"外部工具：

LLM 根據用戶請求決定需要調用哪個工具
返回工具名稱和參數
執行工具獲得結果
將結果反饋給 LLM 繼續推理

3.2 OpenAI Function Calling

python

from openai import OpenAI

client = OpenAI()

# 定義工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "獲取指定城市的天氣信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名稱"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "執行數學計算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "數學表達式"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# 工具實現
def get_weather(city: str) -> str:
    # 實際應用中調用天氣 API
    weather_data = {
        "北京": "晴天，25°C，溼度45%",
        "上海": "多雲，28°C，溼度65%",
        "深圳": "小雨，30°C，溼度80%"
    }
    return weather_data.get(city, f"{city}: 暫無數據")

def calculate(expression: str) -> str:
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"計算錯誤: {e}"

# 調用 LLM
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "北京今天天氣怎麼樣？順便算一下 25 * 4 + 10"}
    ],
    tools=tools,
    tool_choice="auto"
)

# 處理工具調用
message = response.choices[0].message

if message.tool_calls:
    for tool_call in message.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)
        
        if func_name == "get_weather":
            result = get_weather(**func_args)
        elif func_name == "calculate":
            result = calculate(**func_args)
        
        print(f"調用 {func_name}({func_args}) = {result}")

四、LangChain Agent 開發

4.1 使用 LangChain 工具

python

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import DuckDuckGoSearchRun, WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# 初始化 LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 定義工具
search = DuckDuckGoSearchRun()
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())

# 自定義工具
from langchain_core.tools import tool

@tool
def get_current_time() -> str:
    """獲取當前時間"""
    from datetime import datetime
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

@tool
def calculate(expression: str) -> str:
    """執行數學計算，expression 為數學表達式"""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"計算錯誤: {e}"

tools = [search, wikipedia, get_current_time, calculate]

4.2 創建 Agent

python

# 創建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一個智能助手，可以使用工具來幫助用戶完成任務。"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

# 創建 Agent
agent = create_tool_calling_agent(llm, tools, prompt)

# 創建 Agent 執行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5
)

# 運行 Agent
result = agent_executor.invoke({
    "input": "搜索 LangChain 的最新版本信息，並告訴我當前時間"
})

print(result["output"])

4.3 ReAct Agent

ReAct（Reasoning + Acting）是最經典的 Agent 模式：

python

from langchain.agents import create_react_agent

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一個智能助手，按照以下格式思考和行動：

Question: 用戶的問題
Thought: 你應該怎麼思考
Action: 要使用的工具名稱
Action Input: 工具的輸入參數
Observation: 工具的返回結果
... (Thought/Action/Action Input/Observation 可以重複多次)
Thought: 我現在知道最終答案了
Final Answer: 最終答案"""),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

五、記憶系統

5.1 對話記憶

python

from langchain.memory import ConversationBufferMemory

# 基礎記憶（保存完整對話）
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 窗口記憶（只保留最近 K 輪）
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
    k=5,  # 保留最近 5 輪
    memory_key="chat_history",
    return_messages=True
)

# 摘要記憶（對歷史對話做摘要）
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(
    llm=llm,
    memory_key="chat_history"
)

5.2 長期記憶

python

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# 向量存儲作為長期記憶
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
    embedding_function=embeddings,
    persist_directory="./memory_db"
)

# 存儲重要信息
vectorstore.add_texts(["用戶喜歡 Python", "用戶是後端開發者"])

# 檢索相關記憶
relevant_memory = vectorstore.similarity_search("編程語言偏好", k=3)

六、RAG 檢索增強生成

6.1 RAG 原理

用戶提問 → 檢索相關文檔 → 將文檔注入 Prompt → LLM 生成回答

6.2 使用 LlamaIndex 實現 RAG

python

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# 配置模型
Settings.llm = OpenAI(model="gpt-4o")
Settings.embed_model = OpenAIEmbedding()

# 加載文檔
documents = SimpleDirectoryReader("./data").load_data()

# 構建索引
index = VectorStoreIndex.from_documents(documents)

# 創建查詢引擎
query_engine = index.as_query_engine()

# 查詢
response = query_engine.query("LangChain 的主要組件有哪些？")
print(response)

6.3 使用 LangChain 實現 RAG

python

from langchain_community.document_loaders import DirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA

# 加載文檔
loader = DirectoryLoader("./data", glob="**/*.md")
docs = loader.load()

# 分割文檔
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(docs)

# 構建向量存儲
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 創建 RAG 鏈
llm = ChatOpenAI(model="gpt-4o")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# 查詢
result = qa_chain.invoke("什麼是 AI Agent？")
print(result["result"])

七、多 Agent 協作

7.1 Agent 角色分工

python

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate

# 研究員 Agent
researcher_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一個研究員，負責搜索和收集信息。"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])
researcher = create_tool_calling_agent(llm, [search, wikipedia], researcher_prompt)
researcher_executor = AgentExecutor(agent=researcher, tools=[search, wikipedia])

# 寫作者 Agent
writer_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一個技術寫作者，根據研究結果撰寫文章。"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])
writer = create_tool_calling_agent(llm, [], writer_prompt)
writer_executor = AgentExecutor(agent=writer, tools=[])

# 協作流程
research_result = researcher_executor.invoke({"input": "研究 AI Agent 最新進展"})
article = writer_executor.invoke({"input": f"根據以下研究寫一篇文章：\n{research_result['output']}"})
print(article["output"])

7.2 使用 LangGraph 構建複雜工作流

python

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated

# 定義狀態
class AgentState(TypedDict):
    query: str
    research_result: str
    draft: str
    review_feedback: str
    final_output: str

# 定義節點
def research_node(state: AgentState) -> AgentState:
    result = researcher_executor.invoke({"input": state["query"]})
    state["research_result"] = result["output"]
    return state

def write_node(state: AgentState) -> AgentState:
    prompt = f"根據研究寫文章：{state['research_result']}"
    result = writer_executor.invoke({"input": prompt})
    state["draft"] = result["output"]
    return state

def review_node(state: AgentState) -> AgentState:
    # 審核邏輯
    state["review_feedback"] = "文章質量良好"
    return state

# 構建圖
workflow = StateGraph(AgentState)
workflow.add_node("research", research_node)
workflow.add_node("write", write_node)
workflow.add_node("review", review_node)

workflow.set_entry_point("research")
workflow.add_edge("research", "write")
workflow.add_edge("write", "review")
workflow.add_edge("review", END)

app = workflow.compile()
result = app.invoke({"query": "寫一篇關於 AI Agent 的技術文章"})

八、實戰：構建個人助手 Agent

8.1 完整代碼

python

#!/usr/bin/env python3
"""個人助手 Agent - 支持搜索、計算、文件操作"""

import os
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import tool
from langchain.memory import ConversationBufferWindowMemory
from langchain_community.tools import DuckDuckGoSearchRun

# 初始化
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 工具定義
search = DuckDuckGoSearchRun()

@tool
def calculate(expression: str) -> str:
    """執行數學計算"""
    try:
        allowed = set("0123456789+-*/.() ")
        if not all(c in allowed for c in expression):
            return "不安全的表達式"
        return str(eval(expression))
    except Exception as e:
        return f"錯誤: {e}"

@tool
def read_file(file_path: str) -> str:
    """讀取文件內容"""
    try:
        with open(file_path, "r") as f:
            return f.read()[:5000]  # 限制長度
    except Exception as e:
        return f"讀取失敗: {e}"

@tool
def list_directory(dir_path: str = ".") -> str:
    """列出目錄內容"""
    try:
        items = os.listdir(dir_path)
        return "\n".join(items[:50])
    except Exception as e:
        return f"列出失敗: {e}"

tools = [search, calculate, read_file, list_directory]

# 創建 Agent
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是個人智能助手，可以幫助用戶：
    1. 搜索信息
    2. 數學計算
    3. 讀取文件
    4. 管理目錄
    請根據用戶需求選擇合適的工具。"""),
    ("placeholder", "{chat_history}"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

memory = ConversationBufferWindowMemory(
    k=5,
    memory_key="chat_history",
    return_messages=True
)

agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True
)

# 交互循環
while True:
    user_input = input("\n你: ")
    if user_input.lower() in ["exit", "quit"]:
        break
    result = agent_executor.invoke({"input": user_input})
    print(f"\n助手: {result['output']}")

九、生產部署最佳實踐

9.1 成本控制

緩存結果：相同請求返回緩存
限制 Token：設置 max_tokens 防止超長輸出
選擇合適的模型：簡單任務用小模型，複雜任務用大模型
批量處理：合併多個請求

9.2 可靠性

超時設置：防止 LLM 調用無限等待
重試機制：網絡錯誤自動重試
降級策略：主模型不可用時切換備用模型
輸入驗證：清洗用戶輸入，防止注入攻擊

9.3 可觀測性

python

from langchain.callbacks import StdOutCallbackHandler

# 使用回調追蹤
handler = StdOutCallbackHandler()
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    callbacks=[handler],
    verbose=True
)

9.4 安全建議

建議	說明
限制工具權限	只給 Agent 必要的最小權限
審計日誌	記錄所有工具調用
人工審批	危險操作需人工確認
輸入過濾	防止 Prompt 注入
輸出審查	檢查 LLM 輸出的安全性

十、常用框架對比

框架	特點	適用場景
LangChain	生態豐富，組件全面	通用 Agent 開發
LlamaIndex	RAG 能力強，數據索引	知識庫問答
CrewAI	多 Agent 協作	團隊協作場景
AutoGen	微軟出品，對話式	多輪對話
Semantic Kernel	微軟企業級	.NET/企業應用
Dify	低代碼，可視化	快速原型

十一、總結

AI Agent 開發是 2026 年最熱門的方向之一：

從單次問答到自主執行：Agent 能完成複雜的多步任務
工具調用是核心：讓 LLM 與外部世界連接
記憶系統是關鍵：短期記憶+長期記憶實現持續對話
RAG 解決知識問題：讓 Agent 獲取最新和私有知識
多 Agent 協作是趨勢：專業分工，高效協作

🤖 掌握 AI Agent 開發，你就掌握了 AI 應用的未來。

相關文章推薦：

AI Agent 開發入門實戰 2026 ​

一、AI Agent 核心概念 ​

1.1 什麼是 AI Agent ​

1.2 Agent vs 普通 LLM ​

1.3 Agent 架構 ​

二、環境準備 ​

2.1 安裝依賴 ​

2.2 配置 API Key ​

三、工具調用（Function Calling） ​

3.1 什麼是工具調用 ​

3.2 OpenAI Function Calling ​

四、LangChain Agent 開發 ​

4.1 使用 LangChain 工具 ​

4.2 創建 Agent ​

4.3 ReAct Agent ​

五、記憶系統 ​

5.1 對話記憶 ​

5.2 長期記憶 ​

六、RAG 檢索增強生成 ​

6.1 RAG 原理 ​

6.2 使用 LlamaIndex 實現 RAG ​

6.3 使用 LangChain 實現 RAG ​

七、多 Agent 協作 ​

7.1 Agent 角色分工 ​

7.2 使用 LangGraph 構建複雜工作流 ​

八、實戰：構建個人助手 Agent ​

8.1 完整代碼 ​

九、生產部署最佳實踐 ​

9.1 成本控制 ​

9.2 可靠性 ​

9.3 可觀測性 ​

9.4 安全建議 ​

十、常用框架對比 ​

十一、總結 ​

AI Agent 開發入門實戰 2026

一、AI Agent 核心概念

1.1 什麼是 AI Agent

1.2 Agent vs 普通 LLM

1.3 Agent 架構

二、環境準備

2.1 安裝依賴

2.2 配置 API Key

三、工具調用（Function Calling）

3.1 什麼是工具調用

3.2 OpenAI Function Calling

四、LangChain Agent 開發

4.1 使用 LangChain 工具

4.2 創建 Agent

4.3 ReAct Agent

五、記憶系統

5.1 對話記憶

5.2 長期記憶

六、RAG 檢索增強生成

6.1 RAG 原理

6.2 使用 LlamaIndex 實現 RAG

6.3 使用 LangChain 實現 RAG

七、多 Agent 協作

7.1 Agent 角色分工

7.2 使用 LangGraph 構建複雜工作流

八、實戰：構建個人助手 Agent

8.1 完整代碼

九、生產部署最佳實踐

9.1 成本控制

9.2 可靠性

9.3 可觀測性

9.4 安全建議

十、常用框架對比

十一、總結