่ฎฉAI่ชไธป่งๅใๆง่กๅๅญฆไน
๐ ๅบไบLLM็่ชไธปๆบ่ฝไฝๆกๆถ๏ผ่ฎฉAIๅไบบ็ฑปไธๆ ท่งๅไปปๅกใ่ฐ็จๅทฅๅ ทใ็ฎก็่ฎฐๅฟ
ๅฟซ้ๅผๅง โข ๆ ธๅฟ็นๆง โข ๆๆกฃ โข ็คบไพ โข ไผๅๆนๆก
Auto-Agent ๆฏไธไธช่ชไธปๆบ่ฝไฝๆกๆถ๏ผ่ฎฉๅคง่ฏญ่จๆจกๅไธไป ไป ๆฏ่ๅคฉๅทฅๅ ท๏ผ่ๆฏ่ฝๅค่ชไธป่งๅไปปๅกใๆง่กๅคๆๅทฅไฝๆตใ็ฎก็้ฟๆ่ฎฐๅฟ็ๆบ่ฝไปฃ็ใ
- ๐ค ่ชไธปๆง่ก๏ผ่ช็ถ่ฏญ่จๆ่ฟฐ้ๆฑ๏ผAI่ชไธป่งๅๅนถๆง่ก
- ๐ง ๆ็ปญๅญฆไน ๏ผไธๅฑ่ฎฐๅฟ็ณป็ป๏ผๆฏๆไป็ป้ชไธญๅญฆไน ๅๆน่ฟ
- ๐ง ๅทฅๅ ท็ๆ๏ผ็ตๆดป็ๅทฅๅ ท็ณป็ป๏ผๆฏๆ่ชๅฎไนๆฉๅฑ
- ๐ ๅฏ่งๆตๆง๏ผๅฎๆด็ๆง่ก่ฟฝ่ธชๅๆฅๅ็ๆ
ๆฌ้กน็ฎๆๅๅจ DocHive ไธญ่ฟ่ก่ฎพ่ฎกๅ้ช่ฏ๏ผ็ฐๅทฒ็ฌ็ซไธบไธ้จ็ๆบ่ฝไฝๆกๆถใ
โ ๏ธ ๅผๅ็ถๆ๏ผ้กน็ฎๅคไบๆฉๆๅๅฑ้ถๆฎต๏ผAPIๅฏ่ฝๅจๅ็ปญ็ๆฌไธญ่ฐๆดใๅปบ่ฎฎๅจ็ไบง็ฏๅขไธญ่ฐจๆ ไฝฟ็จใ
| ็นๆง | ๆ่ฟฐ | ไบฎ็น |
|---|---|---|
| ่ชไธป่งๅ | ๅบไบLLM็ไปปๅกๅ่งฃๅๆง่ก่ฎกๅ็ๆ | ่ช็ถ่ฏญ่จๆ่ฟฐ้ๆฑ๏ผAI่ชไธป่งๅๆง่ก่ทฏๅพ |
| ๅทฅๅ ท็ณป็ป | ็ตๆดป็ๅทฅๅ ทๆณจๅๆบๅถ๏ผๆฏๆ่ฃ ้ฅฐๅจๅฟซ้ๅฎไน | 3็งๅฎไนๆนๅผ๏ผไป็ฎๅๅฐๅฎๅ จ่ชๅฎไน |
| ๆบ่ฝ้่ฏ | LLM้ฉฑๅจ็้่ฏฏๅๆใๅๆฐไฟฎๆญฃๅ็ญ็ฅๅญฆไน | ไปๅคฑ่ดฅไธญๅญฆไน ๏ผ่ชๅจไผๅๆง่ก็ญ็ฅ |
| ๆๅพ่ทฏ็ฑ | ่ชๅจ่ฏๅซ็จๆทๆๅพๅนถ่ทฏ็ฑๅฐๅ้็ Handler/ๆต็จ | ๆฏๆๅคๅค็ๅจๆฉๅฑ๏ผๅฏ้ๆญฅๆผ่ฟไธบๅคAgent๏ผ |
| ๅฑ็บง | ๅ็งฐ | ๅญๅจๆ ผๅผ | ็ๅฝๅจๆ | ๆ ธๅฟ่ฝๅ |
|---|---|---|---|---|
| L1 | ็ญๆถ่ฎฐๅฟ | ๅ ๅญ | ๅไปปๅก | ๆง่กไธไธๆใไธญ้ดๅณ็ญ่ฎฐๅฝ |
| L2 | ่ฏญไน่ฎฐๅฟ | JSON | ้ฟๆ | ็จๆทๅๅฅฝใ็ฅ่ฏใ็ญ็ฅใ้่ฏฏๆขๅค็ป้ช |
| L3 | ๅไบ่ฎฐๅฟ | Markdown | ้ฟๆ | ้ซ่ฏญไนๅฏๅบฆๆป็ปใPromptๆณจๅ ฅ |
ๅฎ็ฐ็ถๆ
- ๐ ๅ็ฑปๅญๅจ๏ผๅทฒๅฎ็ฐ๏ผ
category/subcategory/tags๏ผ - ๐ ๅ้ฆๅญฆไน ๏ผๅทฒๅฎ็ฐ๏ผ
reward/confidence/needs_revision๏ผ - ๐ฏ ๆบ่ฝๆณจๅ
ฅ๏ผๅทฒๅฎ็ฐ๏ผ
MemoryRouter+token_budget๏ผๅฏ้ LLM ๆป็ป๏ผ - ๐ ๆ็ปญไผๅ๏ผ้จๅๅฎ็ฐ๏ผL1โL2 ๆ็ผใ้่ฏฏๆขๅค็ญ็ฅ่ฎฐๅฟๅ๏ผ
- ๐ ๆง่ก่ฟฝ่ธช๏ผๅฎๆด็LLM่ฐ็จ่ฎฐๅฝๅTokenไฝฟ็จ็ป่ฎก
- ๐ ๆต็จๅฏ่งๅ๏ผMermaidๆต็จๅพ่ชๅจ็ๆ
- ๐ ๆบ่ฝๆฅๅ๏ผMarkdown + HTMLๅๆ ผๅผๆฅๅ่พๅบ
git clone https://github.com/AI-change-the-world/auto_agent.git
cd auto_agent
pip install -e .# OpenAI
export OPENAI_API_KEY=your-api-key
export OPENAI_BASE_URL=https://api.openai.com/v1
export OPENAI_MODEL=gpt-4o-minipython examples/deep_research_demo.py่ฟไธช็คบไพไผๆผ็คบ๏ผ
- ๐ค AI่ชไธป่งๅ็ ็ฉถไปปๅก
- ๐ง ่ชๅจ่ฐ็จๅคไธชๅทฅๅ ท
- ๐ ็ๆๅฎๆด็็ ็ฉถๆฅๅ
- ๐ ๆง่ก่ฟ็จๅฏ่งๅ
่ฟ่กๅไผๅจ examples/output/ ็ฎๅฝ็ๆ๏ผ
- ๐ Markdown็ ็ฉถๆฅๅ
- ๐ HTMLๅฏ่งๅๆฅๅ
- ๐ ่ฏฆ็ป็ๆง่ก่ฟฝ่ธชๆฅๅฟ
๐ก ๆ็คบ๏ผๅฆๆๆๆถๆฒกๆ API Key๏ผๅฏไปฅๅ ็ๆ ้่ฐ็จ LLM ็็คบไพ๏ผcustom_tool.py๏ผไปฅๅ่ฎฐๅฟ็ณป็ป็คบไพ๏ผmemory_demo.pyใ
Auto-Agentๆไพ็ตๆดป็ๅทฅๅ ท็ณป็ป๏ผๆฏๆ3็งๅฎไนๆนๅผ๏ผไป็ฎๅๅฝๆฐๅฐๅคๆๅทฅๅ ทๅบๆๅฐฝๆใ
| ๆนๅผ | ้พๅบฆ | ๅ่ฝ | ้็จๅบๆฏ |
|---|---|---|---|
| ๅฝๆฐ่ฃ ้ฅฐๅจ | โญ | ๅบ็กๅ่ฝ | ็ฎๅๅๆญฅ/ๅผๆญฅๅฝๆฐๅ ่ฃ |
| ็ฑป่ฃ ้ฅฐๅจ | โญโญ | ้ช่ฏ/ๅ็ผฉ | ้่ฆๅๆฐ้ช่ฏๆ็ปๆๅ็ผฉ |
| ็ปงๆฟBaseTool | โญโญโญ | ๅฎๅ จๆงๅถ | ๅคๆ้ป่พใไพ่ตๆณจๅ ฅใ็ถๆ็ฎก็ |
ๆ็ฎๅ็ๅทฅๅ ทๅฎไนๆนๅผ๏ผ้ๅๅ ่ฃ ็ฐๆๅฝๆฐ๏ผ
from auto_agent import func_tool
@func_tool(name="calculator", description="ๆฐๅญฆ่ฎก็ฎๅจ", category="math")
async def calculator(expression: str, precision: int = 2) -> dict:
"""่ฎก็ฎๆฐๅญฆ่กจ่พพๅผ๏ผๆฏๆๅ ๅไน้คๅๅฝๆฐ"""
try:
result = eval(expression)
return {"success": True, "result": round(result, precision)}
except Exception as e:
return {"success": False, "error": str(e)}
@func_tool(name="web_search", description="็ฝ็ปๆ็ดข", category="search")
async def web_search(query: str, limit: int = 5) -> dict:
"""ไฝฟ็จๆ็ดขๅผๆ่ทๅไฟกๆฏ"""
# ๅฎ็ฐๆ็ดข้ป่พ...
return {"success": True, "results": [...], "count": limit}้ๅ้่ฆๅๆฐ้ช่ฏๆ็ปๆๅ็ผฉ็ๅบๆฏ๏ผ
from auto_agent import tool, BaseTool
from typing import Dict, Any
# ่ชๅฎไนๅ็ผฉๅฝๆฐ๏ผๆงๅถไธไธๆ้ฟๅบฆ๏ผ
def compress_search_result(result: Dict[str, Any], state: Dict[str, Any]) -> Dict[str, Any]:
"""ๅ็ผฉๆ็ดข็ปๆ๏ผ้ฟๅ
ไธไธๆๆบขๅบ"""
return {
"success": result.get("success"),
"count": len(result.get("documents", [])),
"top_docs": result.get("documents", [])[:3], # ๅชไฟ็ๅ3ไธช
}
@tool(
name="document_search",
description="ๆๆกฃๅ
จๆๆฃ็ดข",
category="retrieval",
compress_function=compress_search_result, # ็ปๆๅ็ผฉ
)
class DocumentSearchTool(BaseTool):
def __init__(self, index_path: str):
self.index_path = index_path
async def execute(self, query: str, limit: int = 10, **kwargs) -> Dict[str, Any]:
# ๅฎ็ฐๆๆกฃๆ็ดข้ป่พ...
return {
"success": True,
"documents": [...],
"total_found": 25
}้ๅๅคๆๅทฅๅ ท๏ผ้่ฆๅฎๅ จๆงๅถ็ๅฝๅจๆ๏ผ
from auto_agent import BaseTool, ToolDefinition, ToolParameter
class LLMReasoningTool(BaseTool):
"""ไฝฟ็จLLM่ฟ่กๆจ็ๅๆ็ๅทฅๅ
ท"""
def __init__(self, llm_client):
self.llm_client = llm_client
@property
def definition(self) -> ToolDefinition:
return ToolDefinition(
name="llm_reasoning",
description="ไฝฟ็จๅคง่ฏญ่จๆจกๅ่ฟ่กๆจ็ๅๆ",
parameters=[
ToolParameter(
name="question",
type="string",
description="้่ฆๆจ็็้ฎ้ข",
required=True
),
ToolParameter(
name="context",
type="string",
description="็ธๅ
ณไธไธๆไฟกๆฏ",
required=False
),
],
category="reasoning",
# ้่ฏฏๆขๅค้
็ฝฎ
error_recovery={
"max_retries": 2,
"retry_on": ["TIMEOUT_ERROR", "NETWORK_ERROR"]
}
)
async def execute(self, question: str, context: str = "", **kwargs) -> Dict[str, Any]:
"""ๆง่กLLMๆจ็"""
prompt = f"ๅบไบไปฅไธไธไธๆๅ็ญ้ฎ้ข๏ผ\n\nไธไธๆ๏ผ{context}\n้ฎ้ข๏ผ{question}"
try:
response = await self.llm_client.chat([
{"role": "user", "content": prompt}
])
return {
"success": True,
"answer": response,
"confidence": 0.8
}
except Exception as e:
return {"success": False, "error": str(e)}from auto_agent import ToolRegistry, get_global_registry
# ๆนๆณ1๏ผไฝฟ็จๅ
จๅฑๆณจๅ่กจ๏ผ่ฃ
้ฅฐๅจไผ่ชๅจๆณจๅ๏ผ
registry = get_global_registry()
print(f"ๅทฒๆณจๅๅทฅๅ
ทๆฐ้: {len(registry.get_all_tools())}")
# ๆนๆณ2๏ผๆๅจๆณจๅๅฐ่ชๅฎไนๆณจๅ่กจ
custom_registry = ToolRegistry()
custom_registry.register(LLMReasoningTool(llm_client))
custom_registry.register(DocumentSearchTool("./index"))
# ๆนๆณ3๏ผๅจAgentไธญๆๅฎๅทฅๅ
ทๆณจๅ่กจ
agent = AutoAgent(
llm_client=llm_client,
tool_registry=custom_registry,
# ... ๅ
ถไป้
็ฝฎ
)๐ก ๆ็คบ๏ผๆฅ็ examples/custom_tool.py ่ทๅๅฎๆด็คบไพใ
Auto-Agent ้็จไบๅค็งๅคๆ็AIๅบ็จๅบๆฏ๏ผ
- ๆทฑๅบฆ็ ็ฉถ๏ผ่ชๅจ่งๅ็ ็ฉถๆต็จ๏ผๆถ้ๅคๆบไฟกๆฏ๏ผ็ๆ็ปผๅๆฅๅ
- ๅธๅบๅๆ๏ผ็ซไบๅฏนๆๅๆใ่ถๅฟ้ขๆตใๆ่ตๅปบ่ฎฎ็ๆ
- ๆๆฏ่ฐ็ ๏ผๆฐๆๆฏ่ฏไผฐใๆถๆๆนๆก่ฎพ่ฎกใๅฎ็ฐ่ทฏๅพ่งๅ
- ๆๆกฃๅไฝ๏ผๆๆฏๆๆกฃใๅๅฎขๆ็ซ ใ็ ็ฉถๆฅๅ่ชๅจ็ๆ
- ไปฃ็ ็ๆ๏ผๆ นๆฎ้ๆฑ่ชๅจ็ผๅๅไผๅไปฃ็
- ๅๆๅไฝ๏ผๆ ไบๅไฝใ่ฅ้ๆๆกใไธชๆงๅๅ ๅฎน
- ไปปๅก่ชๅจๅ๏ผๅคๆๅทฅไฝๆต็จ็่ชๅจๅๆง่ก
- ้ฎ้ข่งฃๅณ๏ผๅคๆญฅ้ชค้ฎ้ขๅๆๅ่งฃๅณๆนๆก็ๆ
- ๅญฆไน ่พ ๅฏผ๏ผไธชๆงๅๅญฆไน ่ฎกๅๅถๅฎๅ่ฟๅบฆ่ท่ธช
- ๆฐๆฎๅค็๏ผ่ชๅจๆฐๆฎๆธ ๆดใๅๆๅๆฅๅ็ๆ
- ๅฎขๆทๆๅก๏ผๆบ่ฝๅฎขๆใ้ฎ้ข่ฏๆญใ่งฃๅณๆนๆกๆจ่
- ่ฟ่ฅไผๅ๏ผไธๅกๆต็จไผๅใๆ็ๅๆใๆน่ฟๅปบ่ฎฎ
| ็คบไพ | ๅ่ฝ | ๅคๆๅบฆ | ๆไปถ |
|---|---|---|---|
| ๆทฑๅบฆ็ ็ฉถ | ่ชไธป่งๅ็ ็ฉถไปปๅก๏ผ็ๆๅฎๆดๆฅๅ | โญโญโญ | deep_research_demo.py |
| ๅทฅไฝๆตๆผ็คบ | Markdown ๅฎไน Agent โ ๆง่ก โ ็ๆๅฏ่งๅๆฅๅ | โญโญโญ | workflow_demo.py |
| ่ชๅฎไนๅทฅๅ ท | ๅทฅๅ ทๅฎไนๅๆณจๅ็คบไพ | โญ | custom_tool.py |
| ่ฎฐๅฟ็ณป็ป | ่ฎฐๅฟ็ฎก็ๅ่ฝๆผ็คบ | โญโญ | memory_demo.py |
# 1. ้
็ฝฎ็ฏๅขๅ้
export OPENAI_API_KEY=your-api-key
export OPENAI_MODEL=gpt-4o-mini
# 2. ่ฟ่กๆทฑๅบฆ็ ็ฉถ็คบไพ
python examples/deep_research_demo.py
# 3. ๆฅ็็ๆ็็ปๆ
ls examples/output/Auto-Agent ๆไพไธคไธชๆ ธๅฟ็ปไปถ็จไบๅค็็จๆท่ฏทๆฑ๏ผ
| ็ปไปถ | IntentRouter (ๆๅพ่ทฏ็ฑๅจ) | TaskPlanner (ไปปๅก่งๅๅจ) |
|---|---|---|
| ่่ดฃ | ่ฏๅซ็จๆทๆๅพ๏ผ้ๆฉๅชไธช Agent/Handler ๅค็ | ่งๅๅ ทไฝๆง่กๆญฅ้ชค๏ผๅณๅฎ่ฐ็จๅชไบๅทฅๅ ท |
| ่พๅบ | ๅไธ็ปๆ๏ผhandler_name + confidence | ๅคๆญฅ้ชค่ฎกๅ๏ผsteps[] + state_schema |
| ็ฒๅบฆ | ็ฒ็ฒๅบฆ๏ผ้ๆฉๅค็ๅจ๏ผ | ็ป็ฒๅบฆ๏ผ็ผๆๅทฅๅ ท้พ๏ผ |
| ๆถๆบ | ่ฏทๆฑๅ ฅๅฃ๏ผ็ฌฌไธๆญฅ | ็กฎๅฎ Agent ๅ๏ผ่งๅๆง่กๆต็จ |
็จๆท่พๅ
ฅ: "ๅธฎๆๅไธ็ฏAIๆฅๅ"
โ
IntentRouter
โ ่ทฏ็ฑๅฐ "writer" Agent
TaskPlanner
โ ่งๅๆญฅ้ชค
[analyze_input โ search โ outline โ compose]
โ
ๆง่กๅทฅๅ
ท้พ
from auto_agent import IntentRouter, OpenAIClient
# ๅๅงๅ
llm = OpenAIClient(api_key="sk-xxx")
router = IntentRouter(llm_client=llm, default_handler="chat")
# ๆณจๅๅค็ๅจ
router.register(
name="writer",
description="ๆๆกฃๅไฝ๏ผๅ
ๆฌๆฅๅใๆ็ซ ใ็ฌ่ฎฐ็ญ",
keywords=["ๅ", "ๆฐๅ", "ๆๆกฃ", "ๆฅๅ", "ๆ็ซ "],
)
router.register(
name="search",
description="ไฟกๆฏๆฃ็ดขๅๆ็ดข",
keywords=["ๆ็ดข", "ๆฅๆพ", "ๆฃ็ดข"],
)
router.register(
name="qa",
description="้ฎ็ญๅ็ฅ่ฏๆฅ่ฏข",
keywords=["ไปไนๆฏ", "ๅฆไฝ", "ไธบไปไน"],
)
# ่ทฏ็ฑ
result = await router.route("ๅธฎๆๅไธ็ฏๅ
ณไบAI็่ฐ็ ๆฅๅ")
print(f"่ทฏ็ฑๅฐ: {result.handler_name}, ็ฝฎไฟกๅบฆ: {result.confidence}")
# ่พๅบ: ่ทฏ็ฑๅฐ: writer, ็ฝฎไฟกๅบฆ: 0.70from auto_agent.core.planner import TaskPlanner
planner = TaskPlanner(
llm_client=llm,
tool_registry=registry,
agent_goals=["็่งฃ็จๆท้ๆฑ", "็ๆ้ซ่ดจ้ๆๆกฃ"],
agent_constraints=["ๆๆกฃไธ่ถ
่ฟ5000ๅญ"],
)
plan = await planner.plan(
query="ๅไธ็ฏAIๅป็ๆฅๅ",
user_context="็จๆทๆฏๆๆฏไบบๅ",
conversation_context="",
)
for step in plan.subtasks:
print(f"Step {step.id}: {step.tool} - {step.description}")Auto-Agent ๆไพไธๅฑ่ฎฐๅฟๆถๆ๏ผๆฏๆๅ้ฆๅญฆไน ใๆบ่ฝๆณจๅ ฅๅ้่ฏฏๆขๅค็ญ็ฅ่ฎฐๅฟๅใ
| ๅฑ็บง | ๅ็งฐ | ๅญๅจๆ ผๅผ | ็ๅฝๅจๆ | ๆ ธๅฟ็จ้ | ๆดๆฐ้ข็ |
|---|---|---|---|---|---|
| L1 | ็ญๆถ่ฎฐๅฟ | ๅ ๅญ | ๅไปปๅกๆง่ก | ๆง่กไธไธๆใไธญ้ดๅณ็ญใๅทฅๅ ท่ฐ็จ่ฎฐๅฝ | ๅฎๆถ |
| L2 | ่ฏญไน่ฎฐๅฟ | JSON | ้ฟๆๆไน ๅ | ็จๆทๅๅฅฝใ็ฅ่ฏๅบใๆๅ็ญ็ฅใ้่ฏฏๆขๅค็ป้ช | ๅฎๆๆ็ผ |
| L3 | ๅไบ่ฎฐๅฟ | Markdown | ้ฟๆๆไน ๅ | ้ซ่ฏญไนๅฏๅบฆๆป็ปใ่กไธบๆจกๅผๅๆใPromptๆณจๅ ฅ | ๅจๆๆง็ๆ |
๐ฏ ๆถๆไผๅฟ
- ๅๅฑ้็ฆป๏ผไธๅ็ๅฝๅจๆ่ฎฐๅฟๅ็ฆป็ฎก็๏ผ้ฟๅ ็ธไบๅนฒๆฐ
- ๆบ่ฝๆณจๅ ฅ๏ผๅบไบๆฅ่ฏขๆๅพๆ้ๆณจๅ ฅ็ธๅ ณ่ฎฐๅฟ๏ผๆงๅถTokenๆๆฌ
- ๅ้ฆ้ญ็ฏ๏ผ็จๆทๅ้ฆ็ดๆฅๅฝฑๅ่ฎฐๅฟๆ้๏ผๅฝขๆๆ็ปญๅญฆไน ่ฝๅ
- ๅคๆ ผๅผๅญๅจ๏ผJSON็จไบๅณ็ญ๏ผMarkdown็จไบ่ฏญไน็่งฃ
from auto_agent import MemorySystem, MemoryCategory
# ๅๅงๅ็ปไธ่ฎฐๅฟ็ณป็ป
memory = MemorySystem(storage_path="./data/memory", token_budget=2000)
user_id = "user_001"
# === L1 ็ญๆถ่ฎฐๅฟ ===
task_id = memory.start_task(user_id, "ๅธฎๆๅไธ็ฏAIๆฅๅ")
wm = memory.get_working_memory(task_id)
# ่ฎฐๅฝๆง่ก่ฟ็จ
wm.add_decision("ไฝฟ็จๅๅฑ็ปๆ็ป็ปๅ
ๅฎน", "ๆๅๅฏ่ฏปๆง")
wm.add_tool_call("web_search", {"query": "AIๆๆฐ่ฟๅฑ"}, {"success": True, "count": 15})
# ไปปๅก็ปๆๆถๆ็ผๅฐ้ฟๆ่ฎฐๅฟ
memory.end_task(user_id, task_id, promote_to_long_term=True)
# === L2 ่ฏญไน่ฎฐๅฟ ===
# ไพฟๆทๆนๆณ่ฎฐๅฝๅ็ฑป่ฎฐๅฟ
memory.set_preference(user_id, "language", "ไธญๆ")
memory.add_knowledge(user_id, "็จๆท็ฒพ้PythonๅFastAPIๆกๆถ")
memory.add_strategy(user_id, "ๅคๆไปปๅกๅ
ๅ่งฃไธบๅญไปปๅก", is_successful=True)
# ๅ็ฑป็ฎก็
memory.add_memory(
user_id=user_id,
content="็จๆทๅๅฅฝไฝฟ็จๅผๆญฅไปฃ็ ๆจกๅผ",
category=MemoryCategory.PREFERENCE,
tags=["coding", "async"],
confidence=0.9,
)
# === ็จๆทๅ้ฆ้ฉฑๅจๅญฆไน ===
item = memory.add_memory(user_id, "ๅปบ่ฎฎไฝฟ็จ็ฑปๅๆณจ่งฃ")
memory.thumbs_up(user_id, item.memory_id) # ๐ ๆญฃๅ้ฆ
memory.thumbs_down(user_id, item.memory_id, "ๆไบๅบๆฏไธ่ฟไบ็น็") # ๐ ่ดๅ้ฆ
# === ๆบ่ฝ่ฎฐๅฟๆณจๅ
ฅ๏ผๅๆญฅ๏ผ===
ctx = memory.get_context_for_query(user_id, "ๅธฎๆๅไธไธช Web ๅบ็จ")
print(ctx["context"])๐ ่ฏฆ็ปๆๆกฃ๏ผ่ฎฐๅฟ็ณป็ป่ฎพ่ฎก | ่ฟ็งปๆๅ ๐ก ๆดๅฎๆด็่ฎฐๅฟ็ณป็ปๆผ็คบ่ฏท็๏ผ
examples/memory_demo.py
่ชๅจๅๆๆฅ่ฏข๏ผๅณๅฎๆณจๅ ฅๅชไบ่ฎฐๅฟ๏ผ
from auto_agent import MemoryRouter, SemanticMemory, QueryIntent
sm = SemanticMemory()
router = MemoryRouter(sm, default_token_budget=2000)
# ๅๆๆฅ่ฏขๆๅพๅ้ขๅ
analysis = router.analyze_query("ๅธฎๆๆป็ปไธไธไนๅ็ๅญฆไน ็ป้ช")
print(analysis["intent"]) # QueryIntent.REFLECTION
print(analysis["categories"]) # [MemoryCategory.STRATEGY, ...]
# ๅคๆญๆฏๅฆ้่ฆ่ฎฐๅฟ
should_use, reason = router.should_use_memory("ไฝ ๅฅฝ") # False, "็ฎๅ้ฎๅ"
should_use, reason = router.should_use_memory("ๅธฎๆๅไปฃ็ ") # True, "้ขๅ็ธๅ
ณ"
# ่ทๅๆณจๅ
ฅ้
็ฝฎ
config = router.get_memory_injection_config("ๆป็ป็ป้ช")
# {"use_l3_narrative": True, "token_budget": 3000, "priority": "recency"}Auto-Agent ๆไพ LLM ้ฉฑๅจ็ๆบ่ฝ้่ฏๆบๅถ๏ผ่ฝๅคๅๆ้่ฏฏๅๅ ใ่ชๅจไฟฎๆญฃๅๆฐ๏ผๅนถไปๆๅ็ๆขๅค็ญ็ฅไธญๅญฆไน ใ
| ่ฝๅ | ่ฏดๆ |
|---|---|
| ๆบ่ฝ้่ฏฏๅๆ | ไฝฟ็จ LLM ๅๆ้่ฏฏ็ฑปๅใๆ นๅ ๅๅฏๆขๅคๆง |
| ๅๆฐ่ชๅจไฟฎๆญฃ | ๅฝๆฃๆตๅฐๅๆฐ้่ฏฏๆถ๏ผ่ชๅจๆจๆญๆญฃ็กฎๅๆฐๅผ |
| ็ญ็ฅๅญฆไน | ๅฐๆๅ็ๆขๅค็ญ็ฅ่ฎฐๅฝๅฐ L2 ่ฎฐๅฟ๏ผไพๅ็ปญๅค็จ |
| ๅๅฒ็ญ็ฅไผๅ | ้ๅฐ็ฑปไผผ้่ฏฏๆถ๏ผไผๅ ไฝฟ็จๅๅฒๆๅ็ญ็ฅ |
| ้่ฏฏ็ฑปๅ | ๅฏๆขๅคๆง | ้ป่ฎค็ญ็ฅ |
|---|---|---|
PARAMETER_ERROR |
้ซ | LLM ไฟฎๆญฃๅๆฐๅ้่ฏ |
NETWORK_ERROR |
้ซ | ๆๆฐ้้ฟ้่ฏ |
TIMEOUT_ERROR |
ไธญ | ๅขๅ ่ถ ๆถๅ้่ฏ |
RESOURCE_ERROR |
ไธญ | ็ญๅพ ๆๅๆข่ตๆบ |
LOGIC_ERROR |
ไฝ | ่งฆๅ้่งๅ |
PERMISSION_ERROR |
ไฝ | ไธญๆญขๅนถๆฅๅ |
from auto_agent.retry import RetryController, RetryConfig, ErrorType
# ๅๅปบๅธฆ LLM ็้่ฏๆงๅถๅจ
retry_controller = RetryController(
config=RetryConfig(max_retries=3),
llm_client=llm_client,
)
# ๆบ่ฝ้่ฏฏๅๆ
error_analysis = await retry_controller.analyze_error(
exception=e,
context={"state": state, "arguments": args},
tool_definition=tool.definition,
memory_system=memory, # ๅฏ้๏ผๅฏ็จๅๅฒ็ญ็ฅๆฅ่ฏข
)
# ๅๆฐไฟฎๆญฃๅปบ่ฎฎ
if error_analysis.error_type == ErrorType.PARAMETER_ERROR:
fixed_params = await retry_controller.suggest_parameter_fixes(
failed_params=args,
error_analysis=error_analysis,
context={"state": state},
)
# ่ฎฐๅฝๆๅ็ๆขๅค็ญ็ฅ๏ผ่ชๅจๅญฆไน ๏ผ
await retry_controller.record_successful_recovery(
original_error=e,
tool_name="search_documents",
original_params=original_args,
fixed_params=fixed_params,
memory_system=memory,
)ๆง่กๅคฑ่ดฅ
โ
โผ
โโโโโโโโโโโโโโโโโโโ
โ ๆฅ่ฏขๅๅฒ็ญ็ฅ โ โ ไผๅ
ไฝฟ็จ L2 ่ฎฐๅฟไธญ็ๆๅ็ญ็ฅ
โโโโโโโโโโฌโโโโโโโโโ
โ
โโโโโโดโโโโโ
โ ๆๅน้
๏ผ โ
โโโโโโฌโโโโโ
โ
โโโโโโดโโโโโ
ๆฏ ๅฆ
โ โ
โผ โผ
ไฝฟ็จๅๅฒ LLM ๅๆ
็ญ็ฅ้่ฏ ้่ฏฏๅๅ
โ โ
โโโโโโฌโโโโโ
โ
โผ
โโโโโโโโโโโ
โ ๆๅ๏ผ โ
โโโโโโฌโโโโโ
โ
โโโโโโดโโโโโ
ๆฏ ๅฆ
โ โ
โผ โผ
่ฎฐๅฝ็ญ็ฅ ็ปง็ปญ้่ฏ
ๅฐ L2 ๆ้่งๅ
from auto_agent import ExecutionReportGenerator, ExecutionPlan, PlanStep, SubTaskResult
# ็ๆๆฅๅๆฐๆฎ
report_data = ExecutionReportGenerator.generate_report_data(
agent_name="ๆๆกฃๅไฝๆบ่ฝไฝ",
query="ๅไธ็ฏAIๆฅๅ",
plan=plan,
results=results,
state=final_state,
)
# ่ทๅ Mermaid ๆต็จๅพ
print(report_data["mermaid_diagram"])
# graph TD
# Start([ๅผๅง]) --> Step1
# Step1[analyze_input] --> Step2
# Step2[search_documents] --> Step3
# ...
# ็ๆ Markdown ๆฅๅ
markdown = ExecutionReportGenerator.generate_markdown_report(report_data)ๆฏๆไฝฟ็จ Markdown ๅฎไน Agent๏ผ
from auto_agent import AgentMarkdownParser, OpenAIClient
agent_md = """
## ๆๆกฃๅไฝๆบ่ฝไฝ
ไฝ ้่ฆๆไปฅไธๆญฅ้ชคๅฎๆ็จๆท็้ๆฑ๏ผ
1. ่ฐ็จ [analyze_input] ๅทฅๅ
ท๏ผๅๆ็จๆทๆๅพ
2. ่ฐ็จ [es_fulltext_search] ๅทฅๅ
ท๏ผๆฃ็ดข็ธๅ
ณๆๆกฃ
3. ่ฐ็จ [generate_outline] ๅทฅๅ
ท๏ผ็ๆๅคง็บฒ
4. ่ฐ็จ [document_compose] ๅทฅๅ
ท๏ผๆฐๅๆๆกฃ
### ็ฎๆ
- ็่งฃ็จๆท็ๅไฝ้ๆฑ
- ็ๆ็ปๆๆธ
ๆฐ็ๆๆกฃ
### ็บฆๆ
- ๆๆกฃ้ฟๅบฆไธ่ถ
่ฟ5000ๅญ
"""
llm = OpenAIClient(api_key="sk-xxx")
parser = AgentMarkdownParser(llm_client=llm)
result = await parser.parse(agent_md)
if result["success"]:
agent_def = result["agent"]
print(f"Agent: {agent_def.name}")
print(f"Goals: {agent_def.goals}")
print(f"Steps: {[s.tool for s in agent_def.initial_plan]}")โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ User Input โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ IntentRouter โ
โ ่ฏๅซๆๅพ๏ผ้ๆฉ Agent/Handler โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ TaskPlanner โ
โ ่งๅๆง่กๆญฅ้ชค๏ผ็ผๆๅทฅๅ
ท้พ โ
โ โ ่ฎฐๅฟๆณจๅ
ฅ (MemoryRouter) โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Execution Engine โ
โ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ โ
โ โ Tool โ โ Smart Retry โ โ Result โ โ
โ โ Registry โโโ Controller โโโ Compressor โ โ
โ โโโโโโโโโโโโโโโ โ + LLM ้่ฏฏๅๆ โ โโโโโโโโโโโโโโโโ โ
โ โ + ๅๆฐ่ชๅจไฟฎๆญฃ โ โ
โ โ + ๅจๆ้่งๅ โ โ
โ โโโโโโโโโโฌโโโโโโโโโโ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ ็ญ็ฅๅญฆไน
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Memory System (L1/L2/L3) โ
โ โโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โ
โ โ L1 Working โ โ L2 Semantic โ โ L3 Narrative โ โ
โ โ (ไปปๅกไธไธๆ) โ โ (้ฟๆ่ฎฐๅฟ) โ โ (ๅไบๆป็ป) โ โ
โ โ โ โ + ้่ฏฏๆขๅค็ญ็ฅโ โ โ โ
โ โโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
auto_agent/
โโโ core/ # ๐ง ๆ ธๅฟๆบ่ฝไฝๅ่ฝ
โ โโโ agent.py # AutoAgent ไธป็ฑป - ๆบ่ฝไฝๆ ธๅฟ
โ โโโ planner.py # TaskPlanner - ไปปๅก่งๅๅจ
โ โโโ executor.py # ๆง่กๅผๆ
โ โโโ context.py # ๆง่กไธไธๆ็ฎก็
โ โโโ editor/ # Agent Markdown ่งฃๆๅจ
โ โโโ report/ # ๆง่กๆฅๅ็ๆๅจ
โ โโโ router/ # IntentRouter - ๆๅพ่ทฏ็ฑๅจ
โโโ llm/ # ๐ค ๅคง่ฏญ่จๆจกๅๆฏๆ
โ โโโ client.py # LLM ๅฎขๆท็ซฏๆฝ่ฑกๅบ็ฑป
โ โโโ providers/ # ๆจกๅๆไพๅ
โ โ โโโ openai.py # OpenAI GPT ็ณปๅ
โ โ โโโ anthropic.py # Claude ็ณปๅ
โ โ โโโ deepseek.py # DeepSeek ๆจกๅ
โโโ memory/ # ๐ง ไธๅฑ่ฎฐๅฟ็ณป็ป
โ โโโ system.py # ็ปไธ่ฎฐๅฟ็ณป็ป (L1/L2/L3)
โ โโโ working.py # L1 ็ญๆถ่ฎฐๅฟ
โ โโโ semantic.py # L2 ้ฟๆ่ฏญไน่ฎฐๅฟ
โ โโโ narrative.py # L3 ๅไบ่ฎฐๅฟ
โ โโโ router.py # ่ฎฐๅฟ่ทฏ็ฑๅจ
โ โโโ manager.py # ่ฎฐๅฟ็ฎก็ๅจ
โ โโโ models.py # ่ฎฐๅฟๆฐๆฎๆจกๅ
โ โโโ storage/ # ๅญๅจๅ็ซฏ
โ โโโ sqlite.py # SQLite ๅญๅจ
โ โโโ redis.py # Redis ็ผๅญ
โ โโโ markdown.py # Markdown ๆไปถๅญๅจ
โโโ tools/ # ๐ง ๅทฅๅ
ท็ๆ็ณป็ป
โ โโโ base.py # ๅทฅๅ
ทๅบ็ฑป
โ โโโ registry.py # ๅทฅๅ
ทๆณจๅ่กจ
โ โโโ models.py # ๅทฅๅ
ทๆฐๆฎๆจกๅ
โ โโโ builtin/ # ๅ
็ฝฎๅทฅๅ
ท
โ โโโ calculator.py # ่ฎก็ฎๅจๅทฅๅ
ท
โ โโโ code_executor.py # ไปฃ็ ๆง่กๅจ
โ โโโ web_search.py # ็ฝ็ปๆ็ดขๅทฅๅ
ท
โโโ retry/ # ๐ ๆบ่ฝ้่ฏๆบๅถ
โ โโโ controller.py # ้่ฏๆงๅถๅจ
โ โโโ models.py # ้่ฏ้
็ฝฎๆจกๅ
โ โโโ strategies.py # ้่ฏ็ญ็ฅ
โโโ tracing/ # ๐ ๆง่ก่ฟฝ่ธช
โ โโโ context.py # ่ฟฝ่ธชไธไธๆ
โ โโโ models.py # ่ฟฝ่ธชๆฐๆฎๆจกๅ
โโโ utils/ # ๐ ๏ธ ๅทฅๅ
ทๅฝๆฐ
โโโ logger.py # ๆฅๅฟๅทฅๅ
ท
โโโ serialization.py # ๅบๅๅๅทฅๅ
ท
โโโ validators.py # ๆฐๆฎ้ช่ฏๅจ
examples/ # ๐ก ไฝฟ็จ็คบไพ
โโโ deep_research_demo.py # ๆทฑๅบฆ็ ็ฉถๆบ่ฝไฝ
โโโ workflow_demo.py # ๅทฅไฝๆตๆผ็คบ๏ผMarkdown โ ๆง่ก โ ๆฅๅ๏ผ
โโโ memory_demo.py # ่ฎฐๅฟ็ณป็ปๆผ็คบ
โโโ custom_tool.py # ่ชๅฎไนๅทฅๅ
ท็คบไพ
โโโ output/ # ็คบไพ่พๅบ๏ผMarkdown/HTML ๆฅๅ๏ผ
docs/ # ๐ ้กน็ฎๆๆกฃ
โโโ MEMORY.md # ่ฎฐๅฟ็ณป็ป่ฎพ่ฎก่ฏฆ่งฃ
โโโ TOOLS.md # ๅทฅๅ
ทๅผๅๆๅ
โโโ OPTIMIZE.md # ๆง่ฝไผๅๅปบ่ฎฎ
โโโ MIGRATION_GUIDE.md # ็ๆฌ่ฟ็งปๆๅ
tests/ # ๐งช ๆต่ฏๅฅไปถ
โโโ test_memory_system.py # ่ฎฐๅฟ็ณป็ปๆต่ฏ
โโโ test_router.py # ่ทฏ็ฑๅจๆต่ฏ
โโโ test_integration.py # ้ๆๆต่ฏ
# ่ฟ่กๆๆๆต่ฏ
pytest tests/ -v
# ่ฟ่ก็นๅฎๆต่ฏ
pytest tests/test_memory.py -v
# ๆฅ็่ฆ็็
pytest tests/ --cov=auto_agent --cov-report=html๐ก ๆ็คบ๏ผ่ฏทไปฅไฝ ๆฌๅฐ/CI ๅฎ้ ่ฟ่ก็
pytest็ปๆไธบๅ๏ผ้ฟๅ README ไธญ็ๅบๅฎๆฐๅญ่ฟๆ๏ผใ
| ็ฑปๅ | ๆ่ฟฐ |
|---|---|
AutoAgent |
ๆบ่ฝไฝไธป็ฑป |
OpenAIClient |
OpenAI/DeepSeek LLM ๅฎขๆท็ซฏ |
ToolRegistry |
ๅทฅๅ ทๆณจๅ่กจ |
BaseTool |
ๅทฅๅ ทๅบ็ฑป |
IntentRouter |
ๆๅพ่ทฏ็ฑๅจ |
TaskPlanner |
ไปปๅก่งๅๅจ |
MemorySystem |
็ปไธ่ฎฐๅฟ็ณป็ป (L1/L2/L3) |
WorkingMemory |
L1 ็ญๆถ่ฎฐๅฟ |
SemanticMemory |
L2 ้ฟๆ่ฏญไน่ฎฐๅฟ |
NarrativeMemoryManager |
L3 ๅไบ่ฎฐๅฟ |
MemoryRouter |
่ฎฐๅฟ่ทฏ็ฑๅจ |
RetryController |
ๆบ่ฝ้่ฏๆงๅถๅจ |
ExecutionReportGenerator |
ๆง่กๆฅๅ็ๆๅจ |
AgentMarkdownParser |
Agent Markdown ่งฃๆๅจ |
| ่ฃ ้ฅฐๅจ | ๆ่ฟฐ |
|---|---|
@func_tool |
ๅฝๆฐๅทฅๅ ท่ฃ ้ฅฐๅจ๏ผๆ็ฎๆด๏ผ |
@tool |
็ฑปๅทฅๅ ท่ฃ ้ฅฐๅจ๏ผๆฏๆ้ช่ฏ/ๅ็ผฉ๏ผ |
| ๆจกๅ | ๆ่ฟฐ |
|---|---|
ToolDefinition |
ๅทฅๅ ทๅฎไน (ๅซ้่ฏฏๆขๅค้ ็ฝฎ) |
ToolParameter |
ๅทฅๅ ทๅๆฐ |
ErrorRecoveryStrategy |
้่ฏฏๆขๅค็ญ็ฅ้ ็ฝฎ |
ParameterValidator |
ๅๆฐ้ช่ฏๅจ |
ExecutionPlan |
ๆง่ก่ฎกๅ |
PlanStep |
่ฎกๅๆญฅ้ชค |
SubTaskResult |
ๅญไปปๅก็ปๆ |
Session |
ไผ่ฏ |
MemoryItem |
่ฎฐๅฟๆก็ฎ |
MemoryCategory |
่ฎฐๅฟๅ็ฑปๆไธพ |
SemanticMemoryItem |
L2 ่ฏญไน่ฎฐๅฟๆก็ฎ |
UserFeedback |
็จๆทๅ้ฆ |
QueryIntent |
ๆฅ่ฏขๆๅพๆไธพ |
ErrorType |
้่ฏฏ็ฑปๅๆไธพ |
ErrorAnalysis |
LLM ้่ฏฏๅๆ็ปๆ |
ErrorRecoveryRecord |
้่ฏฏๆขๅค่ฎฐๅฝ |
ๆไปฌๆฌข่ฟๅ็งๅฝขๅผ็่ดก็ฎ๏ผๆ ่ฎบๆฏไปฃ็ ใๆๆกฃใๆต่ฏ๏ผ่ฟๆฏ้ฎ้ขๅ้ฆๅๅ่ฝๅปบ่ฎฎใ
- Fork ้กน็ฎไปๅบ
- ๅๅปบๅ่ฝๅๆฏ
git checkout -b feature/amazing-feature # ๆไฟฎๅคbug git checkout -b fix/bug-description - ๆไบคๆดๆน
git commit -m "feat: add amazing new feature" # ้ตๅพช Conventional Commits ่ง่
- ๆจ้ๅนถๅๅปบ PR
git push origin feature/amazing-feature # ๅจ GitHub ไธๅๅปบ Pull Request
# 1. ๅ
้ไปๅบ
git clone https://github.com/AI-change-the-world/auto_agent.git
cd auto_agent
# 2. ๅฎ่ฃ
ๅผๅไพ่ต
pip install -e ".[dev,storage,llm]"
# 3. ่ฟ่กๆต่ฏ
pytest tests/ -v
# 4. ไปฃ็ ๆ ผๅผๅ
black auto_agent/
ruff auto_agent/ --fix- ๐ Bug ไฟฎๅค๏ผไฟฎๅค็ฐๆ้ฎ้ข
- โจ ๆฐๅ่ฝ๏ผๆทปๅ ๆฐ็นๆง
- ๐ ๆๆกฃ๏ผๆน่ฟๆๆกฃๅ็คบไพ
- ๐งช ๆต่ฏ๏ผๆทปๅ ๆๆน่ฟๆต่ฏ
- ๐ง ๅทฅๅ ท๏ผๅผๅๆฐๅทฅๅ ทๆๆน่ฟ็ฐๆๅทฅๅ ท
- ๐จ ้ๆ๏ผไปฃ็ ็ปๆไผๅ
- ๐ ๆๆกฃไธญๅฟ - ่ฏฆ็ปไฝฟ็จๆๅๅๆๆฏๆๆกฃ
- ๐ฌ Issues - ๆฅๅ้ฎ้ขๆๆๅบๅปบ่ฎฎ
- ๐ก Discussions - ่ฎจ่ฎบๅ่ฝๅๆไฝณๅฎ่ทต
- ๐ง ้ฎ็ฎฑ - guchengxi1994@qq.com
ๆ่ฐขๆๆ่ดก็ฎ่ ็ๆฏๆ๏ผ็นๅซๆ่ฐข๏ผ
- DocHive ้กน็ฎ๏ผไธบ Auto-Agent ็ๆ ธๅฟๆๆณๆไพไบ้ช่ฏ
- ๅผๆบ็คพๅบ๏ผๆไพไบไผ็ง็ๅทฅๅ ทๅ็ตๆ
- ๆฉๆ็จๆท๏ผ้่ฟๅ้ฆๅธฎๅฉๆไปฌๆน่ฟไบงๅ
MIT License - ่ช็ฑไฝฟ็จ๏ผไฟ็็ฝฒๅ
ๅฎๆด่ฎธๅฏ่ฏๆๆฌ่ฏทๆฅ็ LICENSE ๆไปถใ
๐ ไฝฟ็จ Auto-Agent ๆๅปบไธไธไปฃๆบ่ฝๅบ็จ๏ผ
ๅฆๆ่ฟไธช้กน็ฎๅฏนไฝ ๆๅธฎๅฉ๏ผ่ฏท็ปๆไปฌไธไธช โญ Star๏ผ