=5/3=========================
Handoffs概念，把任务给另一个Agent
1.每个Agent做专门的事
2.遇到需要的领域，handoff给专业Agent
3.专业Agent处理完，结果返回
4.可以多次handoff，形成Agent团队
例子：
用户：帮我写个爬虫，然后发到我邮箱
Agent1(助手)：收到！写爬虫我交给 —>Agent2（爬虫专家）
Agent2(爬虫专家)：写好代码，handoff给 —》agent3(邮件专家)
Agent(邮件专家)：发送邮件到xxx@email.com
不是真agent只是函数的模拟
import os #操作系统模块，读取环境变量
import json #JSON解析，解析AI返回的参数
from dotenv import load_dotenv #加载.env文件
from openai import OpenAI #OpenAI客户端(MiniMax兼容)

load_dotenv() #加载.env文件到环境变量

client = OpenAI(
base_url=“https://api.minimaxi.com/v1”,
api_key=os.getenv(“ANTHROPIC_API_KEY”)
)

===== 两个专业Agent函数 =====

def agent_weather(city: str) -> str:
“”“天气Agent - 只负责查天气”“”
data = {
“北京”: “晴天，25度”,
“上海”: “雨天，20度”,
“广州”: “多云，28度”,
“深圳”: “晴天，27度”
}
return data.get(city, f"{city}的天气未知")

def agent_news(topic: str) -> str:
“”“新闻Agent - 只负责查新闻”“”
return f"{topic}的最新新闻：AI技术持续发展中…"

def agent_calculator(expression: str) -> str:
“”“计算Agent - 只负责数学计算”“”
try:
result = eval(expression)
return str(result)
except:
return “计算错误”

===== 工具定义 =====

tools = [{
“type”: “function”,
“function”: {
“name”: “agent_weather”, #调用时用的名字
“description”: “天气Agent - 查询城市天气，专门负责天气相关问题”,
“parameters”: {
“type”: “object”,
“properties”: {
“city”: {“type”: “string”, “description”: “城市名称”}
},
“required”: [“city”]
}
}
}, {
“type”: “function”,
“function”: {
“name”: “agent_news”,
“description”: “新闻Agent - 查询新闻资讯，专门负责新闻相关问题”,
“parameters”: {
“type”: “object”,
“properties”: {
“topic”: {“type”: “string”, “description”: “新闻主题”}
},
“required”: [“topic”]
}
}
}, {
“type”: “function”,
“function”: {
“name”: “agent_calculator”,
“description”: “计算Agent - 计算数学表达式，专门负责计算问题”,
“parameters”: {
“type”: “object”,
“properties”: {
“expression”: {“type”: “string”, “description”: “数学表达式，如2+3*5”}
},
“required”: [“expression”]
}
}
}]

TOOLS = {
“agent_weather”: agent_weather,
“agent_news”: agent_news,
“agent_calculator”: agent_calculator
}

===== 系统提示 =====

system_msg = “”"你是一个智能助手，有多个专业Agent可以帮助你：

• agent_weather: 专门查询天气
• agent_news: 专门查询新闻
• agent_calculator: 专门计算数学

当用户问题时，判断需要哪个Agent处理，直接调用对应的Agent。“”"

===== 对话循环 =====

messages = [{“role”: “system”, “content”: system_msg}]

print(“=== Handoffs实验开始 ===”)
print(“你有3个专业Agent: 天气、新闻、计算”)
print(“试试问: ‘北京天气怎么样？’ 或 ‘AI最新新闻’ 或 ‘2+3*5等于多少？’\n”)

while True:
user_input = input("你: ")
if user_input.lower() in [“exit”, “quit”, “退出”]:
print(“再见！”)
break

messages.append({"role": "user", "content": user_input})

response = client.chat.completions.create(
    model="MiniMax-M2.7",
    messages=messages,
    tools=tools
)

assistant_msg = response.choices[0].message
messages.append({"role": "assistant", "content": assistant_msg.content, "tool_calls": assistant_msg.tool_calls})

if not assistant_msg.tool_calls:
    print(f"AI: {assistant_msg.content}\n")
    continue

# 执行工具（handoff给专业Agent）
for tool_call in assistant_msg.tool_calls:
    func_name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)
    
    print(f"→ Handoff给: {func_name}")
    
    if func_name in TOOLS:
        result = TOOLS[func_name](**args)
        print(f"← Agent返回: {result}")
        messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(result)})
    else:
        print(f"← 未知Agent: {func_name}")

# AI根据Agent结果生成最终回答
response2 = client.chat.completions.create(
    model="MiniMax-M2.7",
    messages=messages,
    tools=tools
)

final_msg = response2.choices[0].message
print(f"AI: {final_msg.content}\n")

messages.append({"role": "assistant", "content": final_msg.content})

=Streaming=========================
什么是Streaming?边生成边显示，流水输出
import os
import json
from dotenv import load_dotenv
from openai import OpenAI
import urllib.request
import urllib.error

load_dotenv()

client = OpenAI(
base_url=“https://api.minimaxi.com/v1”,
api_key=os.getenv(“ANTHROPIC_API_KEY”)
)

print(“=== Streaming实验 ===”)
print(“AI会边生成边显示，不用等全部完成\n”)

user_input = input("你: ")

print(“\nAI: “, end=””, flush=True) #end=""不换行，保持在一行 flush=True立即显示，不缓冲

===== Streaming实现 =====

response = client.chat.completions.create(
model=“MiniMax-M2.7”,
messages=[{“role”: “user”, “content”: user_input}],
stream=True # 开启Streaming！ 告诉API要流式响应，边生成边返回，返回一个生成器，不是普通列表
)

逐块读取流式响应

for chunk in response: #api返回的每一小快数据
if chunk.choices and chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end=“”, flush=True)

print(“\n”)
=Memory概念=================
什么是Memonry?
让AI记住之前的对话历史
就像人的记忆一样
实现方式=
1.文件存储：每次对话保存到文件 例子：JSON文件
2.数据库：存到SQLite/MySQL 对话记录表
3.向量数据库 用Embedding存储 Milvus/Pinecone
4.SDK内置 OpenAI Agent SDK 自带 SesionMemory
Memory的核心操作
我自己的想法：全保存，结合对话智能索取，加载
1.保存(Save)

每轮对话后保存

messages.append({“role”: “user”, “content”: “你好”})
save_to_file(messages) # 保存到文件/数据库
2.加载(Load)

下次对话开始时加载

messages = load_from_file() # 从文件/数据库读取
3.压缩(Compress)-进阶

对话太长时压缩

if len(messages) > 100:
messages = compress(messages) # 精简历史
import os #文件操作（删除，重建文件）
import json #
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
base_url=“https://api.minimaxi.com/v1”,
api_key=os.getenv(“ANTHROPIC_API_KEY”)
)

HISTORY_FILE = “conversation_memory.json” #文件存储位置

===== Memory核心函数 =====

def load_memory():
“”“加载记忆（自动处理编码）”“”
if os.path.exists(HISTORY_FILE): #判断文件是否存在
try:
with open(HISTORY_FILE, “r”, encoding=“utf-8”) as f:
return json.load(f)
except UnicodeDecodeError:
# 旧文件是GBK编码，删除重建
os.remove(HISTORY_FILE)
return [{“role”: “system”, “content”: “你是一个有帮助的助手，用简短的语言回答。”}] #默认返回系统消息

def save_memory(messages):
“”“保存记忆”“”
with open(HISTORY_FILE, “w”, encoding=“utf-8”) as f: #必须用utf-8编码，否则emoji会崩溃
json.dump(messages, f, ensure_ascii=False) #ensure_ascii=False保持emoji等Unicode字符

def compress_memory(messages, max_len=20):
“”“压缩记忆（只保留最近N条）”“”
if len(messages) > max_len:
# 保留系统消息 + 最近N条 永远保留第一条，保存近20条
return [messages[0]] + messages[-(max_len):]
return messages

===== 加载记忆 =====

messages = load_memory()

print(“=== Memory实验 ===”)
print(f"已加载 {len(messages)} 条历史记录\n")

显示历史（除了system）

for msg in messages:
if msg[“role”] != “system”:
print(f"{msg[‘role’]}: {msg[‘content’][:30]}…")

print(“\n” + “=”*40 + “\n”)

===== 对话循环 =====

while True:
user_input = input(“你: “)
if user_input.lower() in [“exit”, “quit”, “退出”]:
print(“保存记忆，再见！”)
save_memory(messages)
break
if user_input.lower() == “clear”:
“”“清空记忆”””
os.remove(HISTORY_FILE)
messages = [{“role”: “system”, “content”: “你是一个有帮助的助手。”}]
print(“记忆已清空！\n”)
continue

messages.append({"role": "user", "content": user_input})

response = client.chat.completions.create(
    model="MiniMax-M2.7",
    messages=messages
)

assistant_msg = response.choices[0].message.content
print(f"AI: {assistant_msg}\n")

messages.append({"role": "assistant", "content": assistant_msg})

# 压缩记忆（防止太长）
messages = compress_memory(messages, max_len=20)

# 保存记忆
save_memory(messages)

Guardrails(安全护栏)====================
用户恶意输入 --> Guardrails拦截 ----> 返回安全响应
1.防SQL注入
2.防止敏感信息泄露
3.过滤恶意指令