前言

欢迎回到《2026 Django+Llama 4 AI应用实战》!
在前几讲中,我们通过 RAG 和混合检索,让 Llama 4 变成了一个博学多才的“百科全书”。但无论它多么渊博,始终被困在“只会说、不会做”的牢笼里。当你问它“北京明天的天气如何”时,它只能基于历史数据瞎编;当你让它“帮我查一下订单 1001 的物流状态”时,它更是无能为力。
2026 年的 AI 应用,早就不满足于纯粹的文本生成,智能体才是终局。而打通大模型与真实世界壁垒的第一把钥匙,就是 Function Calling(函数调用)。
Function Calling 允许大模型在对话中输出结构化的 JSON 指令,告诉后端“我需要调用某个函数,参数是什么”,后端执行完毕后将结果返回给模型,模型再基于真实结果回答用户。今天这一讲,我们将为 Llama 4 装上“双手”,让它从被动响应的聊天机器人,进化为能主动执行动作的智能助理。准备好了吗?我们开始!
环境准备
本讲的核心依赖是大模型自身的 Function Calling 能力。目前主流的开源模型(包括 Llama 4)在 Ollama 的驱动下,已经完美兼容了 OpenAI 风格的 Tool Use 协议。无需安装新的 Python 包,请确保你的环境满足以下版本要求:
- Ollama >= 0.3.0
- Llama 4 >= 8B-instruct
如果你的模型版本较低,请先更新:
ollama pull llama4
分步实现
处理 Function Calling 的最大难点在于时序控制:流式输出与多轮工具调用的交织。为了保证系统的稳定性和代码的可读性,我们将采用一种工业界验证过的稳定架构:先非流式意图识别,后流式文本生成。共分 6 步完成。
第 1 步:定义工具规范与执行器
大模型需要知道它“能做什么”以及“怎么做”。我们在 chat/ 目录下新建 tools.py,定义符合 OpenAI 规范的 Schema,并编写真实的执行逻辑。
# chat/tools.py
import json
import logging
logger = logging.getLogger(__name__)
# 模拟真实业务数据源(生产环境替换为数据库或API调用)
MOCK_DATABASE = {
"weather": {
"beijing": "晴天,25°C,空气质量优,东北风3级",
"shanghai": "中雨,18°C,空气质量良,东南风2级",
"guangzhou": "多云,28°C,空气质量优,西南风1级"
},
"orders": {
"1001": "已发货,顺丰快递 SF1234567890,预计明天送达",
"1002": "正在打包中,预计今天下午发货",
"1003": "已签收,签收时间:2026-06-05 14:30"
}
}
# 1. 定义工具的 JSON Schema(告知大模型的能力清单)
# 这是 Function Calling 成功的核心,描述必须清晰无歧义
TOOLS_SCHEMA = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "当且仅当用户明确询问某城市的天气信息时调用此函数。参数必须是中国城市的中文名称,如'北京'、'上海',不要传入'首都'、'魔都'等代称。",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "要查询天气的城市中文名称"
}
},
"required": ["city"]
}
}
},
{
"type": "function",
"function": {
"name": "get_order_status",
"description": "当且仅当用户提供订单编号并询问物流状态时调用此函数。参数必须是纯数字的订单编号,如'1001'。",
"parameters": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "要查询的订单编号"
}
},
"required": ["order_id"]
}
}
}
]
# 2. 工具执行器(真实执行业务逻辑的地方)
class ToolExecutor:
@staticmethod
def execute(tool_name: str, tool_args: dict) –> str:
"""
根据工具名和参数执行函数,返回字符串结果
:param tool_name: 工具名称,与 TOOLS_SCHEMA 中的 name 一致
:param tool_args: 工具参数,由大模型生成的 JSON 解析而来
:return: 工具执行结果的字符串表示
"""
logger.info(f"正在执行工具: {tool_name}, 参数: {tool_args}")
try:
if tool_name == "get_weather":
city = tool_args.get("city", "").strip().lower()
if not city:
return "请提供要查询的城市名称"
result = MOCK_DATABASE["weather"].get(city, f"未查询到{city}的天气信息")
return result
elif tool_name == "get_order_status":
order_id = tool_args.get("order_id", "").strip()
if not order_id:
return "请提供要查询的订单编号"
result = MOCK_DATABASE["orders"].get(order_id, f"未找到编号为{order_id}的订单")
return result
else:
return f"未知工具: {tool_name}"
except Exception as e:
logger.error(f"工具执行失败: {e}", exc_info=True)
return f"工具执行失败: {str(e)}"
关键说明:description 字段是 Function Calling 成功的命门。大模型完全依赖描述来判断何时调用、传什么参。描述必须清晰无歧义,例如“当且仅当用户明确询问某城市天气时调用”,能有效避免模型在问“你叫什么名字”时误调用天气接口。
第 2 步:重构服务层,实现工具调用循环
这是本讲最硬核的部分。流式输出中拼接 tool_calls 的 delta 极易出错。我们采用一种工业界常用的稳定策略:首轮非流式探测意图,末轮流式输出文本。
编辑 chat/services.py,新增 process_chat_with_tools 方法,并确保与之前的 RAG 逻辑完全兼容:
# chat/services.py
import json
import logging
from openai import OpenAI
from django.conf import settings
from .tools import TOOLS_SCHEMA, ToolExecutor
from .retriever import hybrid_retriever
logger = logging.getLogger(__name__)
class Llama4Service:
def __init__(self):
self.client = OpenAI(
base_url=settings.LLAMA4_API_BASE,
api_key=settings.LLAMA4_API_KEY
)
self.model_name = settings.LLAMA4_MODEL_NAME
def get_chat_stream(self, messages: list, use_rag: bool = False):
"""纯流式文本生成(兼容旧逻辑)"""
try:
if use_rag:
query = messages[–1]['content'] if messages else ""
context_docs = hybrid_retriever.search(query)
if context_docs:
context_str = "\\n\\n".join(context_docs)
system_prompt = (
"你是一个专业的企业知识库助手。请严格根据以下【参考资料】回答用户问题。"
"如果【参考资料】中没有相关信息,请诚实地回答'根据现有知识库无法回答',不要自行编造。"
"回答时请保持简洁准确,引用参考资料中的内容。\\n\\n"
f"【参考资料】:\\n{context_str}"
)
if messages and messages[0]['role'] == 'system':
messages[0]['content'] = system_prompt
else:
messages.insert(0, {"role": "system", "content": system_prompt})
stream = self.client.chat.completions.create(
model=self.model_name,
messages=messages,
stream=True,
temperature=0.5 if use_rag else 0.7,
max_tokens=1024
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content is not None:
yield chunk.choices[0].delta.content
except Exception as e:
logger.error(f"流式调用失败: {e}", exc_info=True)
yield "[错误] AI 服务中断,请检查 Ollama 是否运行。"
def process_chat_with_tools(self, messages: list, use_rag: bool = False, max_tool_rounds: int = 2):
"""
处理带工具调用的对话,使用生成器推送事件流
事件类型:
– tool_call: 模型决定调用工具
– tool_result: 工具执行完成
– text: 最终回答的文本片段
:param max_tool_rounds: 最多允许的工具调用轮数,防止死循环
"""
# 注入 RAG 上下文(与工具调用完全兼容)
if use_rag:
query = messages[–1]['content'] if messages else ""
context_docs = hybrid_retriever.search(query)
if context_docs:
context_str = "\\n\\n".join(context_docs)
system_prompt = (
"你是一个智能助手,可以使用提供的工具来回答用户问题。"
"如果问题涉及知识库内容,请优先参考以下【参考资料】回答。"
"如果需要调用工具,请严格按照工具描述使用。\\n\\n"
f"【参考资料】:\\n{context_str}"
)
if messages and messages[0]['role'] == 'system':
messages[0]['content'] = system_prompt
else:
messages.insert(0, {"role": "system", "content": system_prompt})
else:
if not messages or messages[0]['role'] != 'system':
messages.insert(0, {"role": "system", "content": "你是一个智能助手,可以使用提供的工具来回答用户问题。"})
# 工具调用循环(防止无限递归)
for _ in range(max_tool_rounds):
# 非流式请求,让模型判断是否需要调用工具
first_response = self.client.chat.completions.create(
model=self.model_name,
messages=messages,
tools=TOOLS_SCHEMA,
tool_choice="auto",
temperature=0.7,
max_tokens=1024
)
message = first_response.choices[0].message
# 模型没有要求调用工具,或给出了直接回复
if not message.tool_calls:
# 如果模型已经给出了文本回复,直接输出(分块模拟流式)
if message.content:
yield {"type": "text", "content": message.content}
else:
# 否则回退到流式生成
stream = self.client.chat.completions.create(
model=self.model_name,
messages=messages,
stream=True,
temperature=0.7,
max_tokens=1024
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content is not None:
yield {"type": "text", "content": chunk.choices[0].delta.content}
return
# 模型要求调用工具,将 assistant 消息加入历史
messages.append(message)
# 依次执行每个工具调用
for tool_call in message.tool_calls:
function_name = tool_call.function.name
try:
function_args = json.loads(tool_call.function.arguments)
except json.JSONDecodeError:
logger.warning(f"工具参数 JSON 解析失败: {tool_call.function.arguments}")
yield {"type": "text", "content": "抱歉,我无法解析工具参数,请重试。"}
return
# 通知前端:正在调用工具
yield {"type": "tool_call", "name": function_name, "args": function_args}
# 执行真实业务逻辑
result = ToolExecutor.execute(function_name, function_args)
# 通知前端:工具执行结果
yield {"type": "tool_result", "name": function_name, "result": result}
# 将工具执行结果加入历史,供模型反思
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": str(result)
})
# 继续循环,让模型基于工具结果生成最终回答或再次调用工具
continue
# 超过最大轮数,提示用户
yield {"type": "text", "content": "工具调用次数过多,已停止。请简化问题或稍后重试。"}
llama4_service = Llama4Service()
关键说明:
- 通过使用 Python 的生成器(yield 字典),我们将服务层的处理过程变成了一个事件流,无论模型调用了几个工具都能稳定处理。
- 增加了 max_tool_rounds 参数防止无限循环(例如模型反复调用同一个工具)。
- 当模型没有调用工具但已经给出直接回复(message.content)时,直接输出该内容,避免二次请求,提升效率。
- 完美保留了 RAG 功能,实现了“知识库 + 工具调用”的双重增强。
第 3 步:重构视图层,推送多类型 SSE 事件
修改 chat/views.py 中的 chat_stream_api,解析服务层抛出的事件字典,封装为不同类型的 SSE 消息,并确保与之前的逻辑完全兼容。
# chat/views.py 完整修改(仅展示核心部分,其他视图保持不变)
import json
import logging
from django.http import StreamingHttpResponse, JsonResponse
from django.views.decorators.http import require_POST
from django.shortcuts import get_object_or_404
from .models import Conversation, Message
from .services import llama4_service
logger = logging.getLogger(__name__)
@require_POST
def chat_stream_api(request):
try:
data = json.loads(request.body)
user_message = data.get("message", "").strip()
conv_id = data.get("conversation_id")
use_rag = data.get("use_rag", True) # 默认开启 RAG
use_tools = data.get("use_tools", True) # 默认开启工具调用
if not user_message:
return JsonResponse({"error": "消息不能为空"}, status=400)
except json.JSONDecodeError:
return JsonResponse({"error": "无效的请求数据"}, status=400)
# 获取或创建会话
if conv_id:
conv = get_object_or_404(Conversation, id=conv_id)
else:
# 新会话用消息前20字做标题
title = user_message[:20] if len(user_message) > 20 else user_message
conv = Conversation.objects.create(title=title)
# 保存用户消息
Message.objects.create(conversation=conv, role='user', content=user_message)
# 构建历史上下文(滑动窗口,保留最近10条)
history_msgs = conv.messages.all().order_by('-created_at')[:10]
history_msgs = reversed(history_msgs)
api_messages = [{"role": msg.role, "content": msg.content} for msg in history_msgs]
full_ai_response = ""
def event_stream():
nonlocal full_ai_response
try:
if use_tools:
event_generator = llama4_service.process_chat_with_tools(api_messages, use_rag=use_rag)
else:
event_generator = llama4_service.get_chat_stream(api_messages, use_rag=use_rag)
for event in event_generator:
if use_tools and isinstance(event, dict):
# 处理工具调用事件流
if event["type"] == "tool_call":
data_json = json.dumps({
"type": "tool_call",
"name": event["name"],
"args": event["args"]
}, ensure_ascii=False)
yield f"data: {data_json}\\n\\n"
elif event["type"] == "tool_result":
data_json = json.dumps({
"type": "tool_result",
"name": event["name"],
"result": event["result"]
}, ensure_ascii=False)
yield f"data: {data_json}\\n\\n"
elif event["type"] == "text":
full_ai_response += event["content"]
data_json = json.dumps({
"type": "text",
"content": event["content"],
"conversation_id": conv.id
}, ensure_ascii=False)
yield f"data: {data_json}\\n\\n"
else:
# 纯流式文本(兼容旧逻辑)
text_chunk = event
full_ai_response += text_chunk
data_json = json.dumps({
"type": "text",
"content": text_chunk,
"conversation_id": conv.id
}, ensure_ascii=False)
yield f"data: {data_json}\\n\\n"
except Exception as e:
logger.error(f"流生成异常: {e}", exc_info=True)
full_ai_response = "抱歉,服务出现异常,请稍后重试。"
data_json = json.dumps({
"type": "text",
"content": full_ai_response,
"conversation_id": conv.id
}, ensure_ascii=False)
yield f"data: {data_json}\\n\\n"
finally:
if full_ai_response:
Message.objects.create(conversation=conv, role='assistant', content=full_ai_response)
yield "data: [DONE]\\n\\n"
response = StreamingHttpResponse(event_stream(), content_type='text/event-stream')
response["Cache-Control"] = "no-cache"
response["X-Accel-Buffering"] = "no" # 禁用 Nginx 缓冲
return response
第 4 步:前端适配,渲染工具调用卡片
类似 ChatGPT 那样,当 AI 调用工具时,我们应该在界面上展示一个“正在搜索…”或“正在查询…”的状态卡片,这极大地提升了用户体验。同时,确保工具卡片与 Markdown 文本可以正确共存。
首先在 <style> 标签中增加工具卡片的样式(可与已有样式合并):
/* 工具调用卡片样式 */
.tool-card {
display: inline-flex;
align-items: center;
gap: 8px;
background: #e0e7ff;
color: #4338ca;
padding: 6px 12px;
border-radius: 8px;
font-size: 0.85em;
margin-bottom: 8px;
animation: pulse 1.5s infinite;
}
.tool-card.done {
background: #dcfce7;
color: #166534;
animation: none;
}
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.6; }
}
.text-container {
margin-top: 8px;
line-height: 1.6;
}
然后修改 chat/templates/chat/index.html 中的 sendMessageStream 函数,处理不同类型的 SSE 事件(注意保持之前流式渲染和 Markdown 高亮逻辑的完整性):
// 在现有的 sendMessageStream 函数中替换为以下实现
async function sendMessageStream() {
const message = inputField.value.trim();
if (!message) return;
inputField.value = '';
sendBtn.disabled = true;
inputField.disabled = true;
addMessage('user', message);
const aiBubble = addMessage('ai', '');
let fullResponse = '';
let textContainer = null; // 存放最终文本的容器
let toolCards = []; // 存储当前气泡中的所有工具卡片(支持多个连续调用)
try {
const response = await fetch('/api/chat/stream/', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
message: message,
conversation_id: currentConversationId,
use_rag: true,
use_tools: true
})
});
if (!response.ok) {
throw new Error('服务器响应错误');
}
const reader = response.body.getReader();
const decoder = new TextDecoder('utf-8');
let buffer = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split('\\n\\n');
buffer = lines.pop();
for (const line of lines) {
if (!line.startsWith('data: ')) continue;
const dataStr = line.slice(6);
if (dataStr.trim() === '[DONE]') break;
try {
const parsed = JSON.parse(dataStr);
if (parsed.type === 'tool_call') {
// 创建新的工具卡片
const toolNameMap = {
'get_weather': '查询天气',
'get_order_status': '查询物流'
};
const displayName = toolNameMap[parsed.name] || parsed.name;
const card = document.createElement('div');
card.className = 'tool-card';
card.innerHTML = `
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
<circle cx="12" cy="12" r="10"></circle>
<line x1="12" y1="8" x2="12" y2="12"></line>
<line x1="12" y1="16" x2="12.01" y2="16"></line>
</svg>
正在${displayName}…
`;
aiBubble.appendChild(card);
toolCards.push(card);
scrollToBottom();
} else if (parsed.type === 'tool_result') {
// 找到最近的一个未完成的工具卡片,标记为完成
if (toolCards.length > 0) {
const lastCard = toolCards[toolCards.length – 1];
lastCard.className = 'tool-card done';
lastCard.innerHTML = `
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"></path>
<polyline points="22 4 12 14.01 9 11.01"></polyline>
</svg>
已获取数据
`;
// 可选:显示结果摘要
if (parsed.result && parsed.result.length < 50) {
lastCard.innerHTML += `<span style="margin-left: 8px; font-size:0.85em;">${parsed.result}</span>`;
}
}
scrollToBottom();
} else if (parsed.type === 'text') {
// 收到最终文本,开始流式渲染
aiBubble.classList.remove('typing-cursor');
fullResponse += parsed.content;
// 创建文本容器(如果不存在)
if (!textContainer) {
textContainer = document.createElement('div');
textContainer.className = 'text-container';
aiBubble.appendChild(textContainer);
}
// 渲染 Markdown(复用之前的 fixUnclosedCodeBlocks 和 marked 逻辑)
const renderText = fixUnclosedCodeBlocks(fullResponse);
const rawHtml = marked.parse(renderText);
textContainer.innerHTML = DOMPurify.sanitize(rawHtml);
scrollToBottom();
}
if (parsed.conversation_id) {
currentConversationId = parsed.conversation_id;
}
} catch (e) {
console.warn('解析流数据失败:', dataStr, e);
}
}
}
} catch (error) {
console.error('请求错误:', error);
fullResponse = '请求中断,请重试。';
if (textContainer) {
textContainer.textContent = fullResponse;
} else {
aiBubble.textContent = fullResponse;
}
} finally {
aiBubble.classList.remove('typing-cursor');
sendBtn.disabled = false;
inputField.disabled = false;
inputField.focus();
scrollToBottom();
}
}
关键说明:
- 使用 toolCards 数组维护多个工具卡片,支持模型在一次对话中连续调用多个工具(例如先查天气再查物流)。
- 工具结果卡片会显示简要的结果摘要(如果结果较短)。
- 文本容器 textContainer 只在收到第一个 text 事件时创建,保证 Markdown 渲染的连续性。
第 5 步:运行与验证
确保所有文件保存后,Django 服务会自动重载。如果未启动,执行:
python manage.py runserver
测试效果
我们将进行多场景测试,验证工具调用的准确性和稳定性。
1. 天气查询测试
输入:“上海今天天气怎么样?会下雨吗?”
- 观察 UI:AI 气泡内首先出现一个紫色的动态卡片“正在查询天气…”
- 几百毫秒后:卡片变为绿色的“已获取数据”,并可能显示“中雨,18°C”
- 最终回答:AI 开始流式输出:“上海今天中雨,18°C,空气质量良,东南风2级。记得带伞哦!”
2. 物流查询测试
输入:“帮我看看订单 1001 到哪了?”
- 观察 UI:出现“正在查询物流…”卡片,随后变为“已获取数据”
- 最终回答:“订单 1001 目前已发货,顺丰快递 SF1234567890,预计明天送达。”
3. 多工具调用测试
输入:“北京天气怎么样?订单 1002 的状态是什么?”
- 观察 UI:依次出现“正在查询天气…”和“正在查询物流…”两个卡片,每个完成后变为绿色。
- 最终回答:AI 会整合两个工具的结果,给出完整回答:“北京今天晴天,25°C,空气质量优。订单 1002 正在打包中,预计今天下午发货。”
4. 普通对话测试
输入:“你是谁?你能做什么?”
- 观察 UI:不会出现任何工具卡片
- 最终回答:AI 直接流式回答:“我是 Llama 4 智能助手,我可以帮你查询天气、物流状态,还可以回答知识库中的问题。”
5. RAG + 工具调用混合测试
先上传包含“公司年假规定”的文档,然后输入:“公司年假规定是什么?北京明天天气怎么样?”
- 观察 UI:出现“正在查询天气…”卡片
- 最终回答:AI 会同时回答知识库中的年假规定和查询到的天气信息,完美实现双重增强。
3 个常见坑
Function Calling 是一把双刃剑,初学者极易踩中以下三个坑,导致系统行为异常。
坑 1:Schema 描述模糊导致模型“无脑调工具”或“瞎传参”
现象:用户问“你叫什么名字”,模型竟然调用了 get_weather;或者用户问“北京天气”,模型传参 {"city": "首都"}。
原因:大模型对工具的理解完全依赖于 description 字段。如果你的描述是“获取天气”,模型可能会觉得闲聊也跟天气有关;如果参数描述没写清楚“只接受城市名”,模型就会自由发挥。
解决:遵循约束性描述原则。写成“当且仅当用户明确询问某城市天气时调用。参数必须是中国城市的中文名称,如’北京’、‘上海’,不要传入’首都’等代称”。在 Prompt 层面加上强约束,是解决幻觉的最有效手段。
坑 2:在流式输出中强行拼接 tool_calls 导致崩溃
现象:试图在 stream=True 的情况下拼接 delta.tool_calls,结果遇到参数截断(如参数输出了 {"ci 就断了),导致 json.loads 解析失败,服务端 500 报错。
原因:在流式模式下,函数名和参数也是逐字输出的,必须维护复杂的缓冲区来拼接完整的 JSON,一旦遇到网络抖动或模型输出格式轻微偏差,就会崩塌。
解决:这正是我们在第 2 步采用“首轮非流式探测”的原因。对于需要极高精确度的结构化数据提取,坚决不要用流式。我们牺牲了首次意图识别的几百毫秒延迟,换来的是 100% 的参数解析成功率。拿到参数执行完工具后,再进行流式输出,体验和稳定性实现了双赢。
坑 3:工具调用死循环(无限套娃)
现象:模型调用了工具,拿到结果后,又输出了同样的 tool_calls,陷入了死循环,直到超出最大上下文长度报错。
原因:历史消息构建错误。在模型返回 tool_calls 时,必须将这条 role=assistant 且包含 tool_calls 的消息原封不动地加入历史;同时,执行结果必须以 role=tool 且携带相同 tool_call_id 的消息加入。如果漏加了 assistant 的消息,或者 ID 对不上,模型就会失忆,以为自己还没调过工具,不断重复调用。
解决:严格遵守 OpenAI 的消息协议。在 services.py 中,messages.append(message) 和 messages.append({"role": "tool", "tool_call_id": tool_call.id, …}) 这两步缺一不可,且顺序不能颠倒。同时设置 max_tool_rounds 限制最大轮数,作为兜底保护。
专栏目录与订阅
本文是《2026 Django+Llama 4 AI应用实战》专栏的第八讲,完整专栏持续更新中,你可以在以下地址查看所有文章和后续章节:
专栏主页:https://blog.csdn.net/zsh_1314520/category_13175252.html
本专栏将从零带你搭建生产级可上线的 AI 全栈项目,涵盖大模型 API 集成、RAG 检索增强、智能对话系统、AI 内容生成等核心场景,详解 Django 后端架构优化、大模型调用封装、流式响应实现等工业级实战内容。全部代码基于真实项目提炼,可直接用于你自己的业务系统。
建议你收藏专栏主页,方便第一时间获取更新。
下一篇预告
今天我们通过 Function Calling,让 AI 拥有了执行动作的能力。但目前的调用逻辑是写死在代码里的“如果匹配A则执行A”。真正的 Agent 应该具备自主规划能力——给定一个复杂目标,它能自己拆解步骤,自己选择工具,自己判断是否完成。
在 第 9 讲:《从工具调用到自主规划:用 Django 手搓一个 ReAct 模式智能体》 中,我将带你打破固化的代码逻辑,实现经典的 ReAct(Reasoning and Acting)框架,让 Llama 4 拥有真正的“大脑”。敬请期待!
本专栏持续更新中,点击专栏主页或关注我获取完整教程。


