Gemini 3 Pro 是大家期待已久的最新的 AI 模型，它拥有百万级别的超大上下文窗口，能一次性处理海量数据集、文档、视频和代码库。它不仅具备博士级别的推理能力，在文本、图像、音频、视频等多模态处理上也都表现出色，能让你的创意工作流变得更加流畅。
在这篇文章里，我打算手把手教大家如何利用 Gemini 3 API 来搭建一个多智能体应用。这个应用能接收用户提供的 CSV 数据集，然后自动进行深入的数据分析。
简单来说，我们这个多智能体应用会做这些事情：
- 初步分析：快速了解数据集的结构和基础信息。
- 代码生成：让 Gemini 3 Pro 生成高级分析代码，包含数据可视化。
- 安全执行：在沙盒环境里安全运行生成的代码，并保存结果。
- 智能推理：分析并解读分析结果，提炼出核心洞察。
- PDF 报告编制：生成一份精美的 PDF 报告，里面有图表和清晰的解释，让你一眼就能抓住关键点。
如果你对构建这种智能体驱动的 AI 工作流感兴趣，我个人推荐去看看 DataCamp 上关于 Google Antigravity 的指南、Gemini 3 Flash 教程，以及 AI Agent Fundamentals 技能路径，里面有很多实用的东西。
1. 准备 Gemini 3 API 环境
首先，我们要安装所有必需的 Python 包来运行我们的多智能体应用。
!pip install -q google-genai langgraph langsmith grandalf pydantic pandas matplotlib markdown2 weasyprint markdown-it-py mdit-py-plugins
这些包各有什么用处呢？我给大家简单梳理下：
google-generativeai：这是访问 Gemini 3 Pro 官方 API 的通道。langgraph：一个很棒的库，能帮助我们轻松编排多智能体 AI 工作流。langsmith：用来跟踪运行、监控性能和调试的，它的交互式仪表板特别好用。grandalf：能把我们的智能体图谱绘制成简洁的 ASCII 图。pydantic：用于管理共享图状态，提供了强大的数据验证功能。pandas：做数据探索和分析的利器，大家都知道的。matplotlib：生成漂亮的数据可视化图表。markdown2：将 Markdown 文本转换成 HTML，用于丰富报告格式。weasyprint：这个库能把 HTML/CSS 转换成专业的 PDF 报告。markdown-it-py：一个高级的 Markdown 解析器，能处理更复杂的格式。mdit-py-plugins：markdown-it-py的插件，支持表格、脚注等功能。
小提示：我这个项目是在 Jupyter Notebook 里构建的，所以上面的安装命令可以直接在 Notebook 里运行。
接下来，你需要准备好 API 密钥：
- 访问 Google AI Studio，生成你的 Gemini API 密钥。注意，Gemini 3 Pro 模型不是免费的，所以你的账户需要启用计费功能。
- 然后，注册一个免费的 LangSmith 账户，并生成对应的 API 密钥。
把这两个 API 密钥都保存为本地系统的环境变量，分别命名为 LANGSMITH_API_KEY 和 GEMINI_API_KEY。
导入必要的 Python 包：
from google import genai
from google.genai import types
from pydantic import BaseModel
from langgraph.graph import StateGraph, END
import os, json, textwrap, traceback
from pathlib import Path
import pandas as pd
import markdown2
import weasyprint
设置环境变量，指定 LangSmith 项目名称并启用 LangSmith 跟踪：
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = os.environ.get("LANGSMITH_API_KEY", "YOUR_LANGSMITH_KEY")
os.environ["LANGSMITH_PROJECT"] = os.environ.get("LANGSMITH_PROJECT", "autolab-gemini3pro")
最后，创建一个文件夹，用来保存所有生成的图像和 PDF 文件：
ARTIFACTS_DIR = Path("artifacts")
ARTIFACTS_DIR.mkdir(exist_ok=True)
2. 初始化 Gemini 3 API 客户端
这一步，我们要设置 Gemini API 客户端，并对模型调用进行封装，这样就可以在 LangSmith 中跟踪和记录它们了。同时，我们还会提取 token 使用情况的元数据，并以 LangSmith 友好的格式返回。
首先，用你的 API 密钥初始化 Gemini GenAI 客户端：
client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
MODEL = "gemini-3-pro-preview"
接着，我们会编写一个小的包装器函数，它负责调用 Gemini 模型，并启用 LangSmith 的自动跟踪功能。通过 @traceable 装饰器，我们把这个函数注册为一个 LLM 运行。
在这个函数内部，代码会将提示发送给 Gemini，并提取 token 使用的详细信息。这些信息对 LangSmith 的准确跟踪非常重要，因为它是按照跟踪指南来的。
最终，这个函数会返回模型的文本输出，以及 token 统计数据和原始响应，这些都会以 LangSmith 期望的格式返回，确保在 UI 中能正确显示运行情况。
from langsmith import traceable
@traceable(name="gemini_generate_content", run_type="llm")
def gemini_call(prompt: str, thinking_level: str = "high"):
"""
Gemini wrapper that:
- uses correct ThinkingConfig schema
- returns LangSmith LLM-run format so token usage shows in UI
"""
resp = client.models.generate_content(
model=MODEL,
contents=prompt,
config=types.GenerateContentConfig(
thinking_config=types.ThinkingConfig(thinking_level=thinking_level)
),
)
usage = getattr(resp, "usage_metadata", None)
token_usage = None
if usage:
token_usage = {
"prompt_tokens": usage.prompt_token_count,
"completion_tokens": usage.candidates_token_count,
"total_tokens": usage.total_token_count,
"thoughts_tokens": getattr(usage, "thoughts_token_count", None),
}
return {
"generations": [{"text": resp.text}],
"llm_output": {
"model_name": MODEL,
"token_usage": token_usage,
},
"raw_response": resp,
}
3. 为多智能体 Gemini 3 工作流构建工具
现在，我们来创建一些工具。这些工具将提供数据集检查、安全的 Python 代码执行以及 Markdown 到 PDF 的报告生成功能，它们会集成到我们的 AI 智能体工作流中。
工具 1: 加载数据集
这个工具接收一个文件路径，用 pandas 把 CSV 文件读入一个 DataFrame，然后生成一个包含数据集形状、列名、每列数据类型、缺失值百分比、前五行数据以及完整的描述性统计信息的摘要。它会返回这份摘要，这样智能体就能快速了解数据集的情况了。
def load_dataset(path: str):
df = pd.read_csv(path)
summary = {
"shape": df.shape,
"columns": list(df.columns),
"dtypes": {c: str(t) for c, t in df.dtypes.items()},
"missing_pct": df.isna().mean().to_dict(),
"head": df.head(5).to_dict(orient="records"),
"describe": df.describe(include="all").fillna("").to_dict()
}
return summary
工具 2: 安全执行 Python 代码 (简易沙盒)
这个工具的作用是在一个受限制的环境中安全地运行动态生成的 Python 代码。它会准备一个小的本地环境，然后用 exec 函数执行提供的代码。
我们预期执行的代码会返回一些“产物”路径（比如保存的图表）和元数据。
def run_python(code: str):
"""
Generated code MUST:
- save plots to ARTIFACTS_DIR
- collect paths in _artifacts (list[str])
- collect meta in _charts_meta (list[dict])
- optionally set _stdout (string)
"""
local_env = {"ARTIFACTS_DIR": ARTIFACTS_DIR}
try:
exec(textwrap.dedent(code), {}, local_env)
return {
"ok": True,
"stdout": local_env.get("_stdout", ""),
"artifacts": local_env.get("_artifacts", []),
"charts_meta": local_env.get("_charts_meta", []),
}
except Exception:
return {"ok": False, "traceback": traceback.format_exc()}
工具 3: 从 Markdown 渲染 PDF
这个工具负责把 Markdown 文本转换成格式漂亮的 PDF 文件。它首先会构建一个支持表格、列表、任务列表和脚注的 Markdown 解析器。
然后 render_pdf 函数会把 Markdown 文本转换成 HTML，并用自定义的 CSS 样式模板（控制字体、表格外观、图片尺寸等）进行封装，最后利用 WeasyPrint 生成 PDF 文件。
最终，它把 PDF 保存到 artifacts 文件夹，并返回文件路径。
from markdown_it import MarkdownIt
from mdit_py_plugins.tasklists import tasklists_plugin
from mdit_py_plugins.footnote import footnote_plugin
# Create a strong markdown parser once (supports tables, lists, etc.)
md = (
MarkdownIt("commonmark", {"breaks": True, "html": True})
.enable(["table", "strikethrough"])
.use(tasklists_plugin)
.use(footnote_plugin)
)
def render_pdf(markdown_text: str):
"""
Better Markdown -> HTML -> PDF:
- proper tables
- stable lists
- centered/small images
- clean page breaks
"""
html_body = md.render(markdown_text)
html_template = f"""
<html>
<head>
<meta charset="utf-8">
<style>
body {{
font-family: Arial, sans-serif;
font-size: 12px;
line-height: 1.5;
color: #111;
}}
h1 {{ font-size: 20px; margin-bottom: 6px; }}
h2 {{ font-size: 16px; margin-top: 18px; margin-bottom: 6px; }}
h3 {{ font-size: 13px; margin-top: 12px; margin-bottom: 4px; }}
p {{ margin: 6px 0; }}
ul, ol {{
margin: 6px 0 6px 18px;
}}
li {{ margin: 2px 0; }}
table {{
width: 100%;
border-collapse: collapse;
margin: 8px 0 12px 0;
font-size: 11px;
}}
th, td {{
border: 1px solid #ccc;
padding: 6px;
text-align: left;
}}
th {{ background: #f2f2f2; }}
img {{
display: block;
margin: 8px auto 8px auto;
max-width: 70%;
height: auto;
page-break-inside: avoid;
}}
.chart-block {{
page-break-inside: avoid;
margin-bottom: 12px;
}}
code {{
background: #f6f6f6;
padding: 2px 4px;
border-radius: 4px;
font-size: 11px;
}}
pre code {{
display: block;
padding: 8px;
overflow-x: auto;
}}
</style>
</head>
<body>
{html_body}
</body>
</html>
"""
pdf_path = ARTIFACTS_DIR / "report.pdf"
weasyprint.HTML(
string=html_template,
base_url=str(ARTIFACTS_DIR.parent.resolve())
).write_pdf(str(pdf_path))
return str(pdf_path)
现在，我们把这三个函数都注册为智能体可用的工具。
TOOLS = [load_dataset, run_python, render_pdf]
4. 共享图状态 (Shared Graph State)
这个类定义了一个共享的 state 对象，它保存着智能体工作流生成的所有内容：比如数据集路径、分析概要、生成的计划、代码、执行结果、洞察报告，以及重试次数限制和错误信息，这些都是为了避免出现无限循环。
class State(BaseModel):
dataset_path: str
profile: dict | None = None
plan: dict | None = None
code: str | None = None
exec_result: dict | None = None
charts_meta: list | None = None
insights: str | None = None
report_md: str | None = None
report_pdf: str | None = None
retry_count: int = 0 # NEW: stop infinite loops
last_error: str | None = None # NEW: pass traceback to coder
MAX_RETRIES = 2
5. 为数据分析创建 Gemini 3 API 智能体
现在我们来创建一系列 AI 智能体，它们将协同合作，完成数据集分析、编写和执行代码、生成洞察，并最终生成一份 PDF 报告。
智能体 1: 数据概览与规划者 (Data Profiler and Planner)
这个智能体负责理解数据集并制定一个结构化的分析计划。它首先使用 load_dataset 工具加载数据集，这个工具会给它一个总结，包含数据集的形状、缺失值情况、列类型、描述性统计信息和示例行。
接着，它把这个数据集摘要发送给 LLM，并给出非常明确的指示：识别任务类型、选择目标列（如果适用）、决定需要采取哪些探索性步骤、建议生成哪些图表，以及如果数据集涉及分类或回归任务，要概述相应的建模步骤。
LLM 会返回一个表示此计划的 JSON 结构，智能体解析它，如果 JSON 解析失败就回退到存储原始文本。
最后，它将数据集概览和生成的计划都保存到共享状态中，这样后续的智能体就能获取到所有必要的信息了。
@traceable(name="profiler_agent")
def profiler_agent(state: State):
profile = load_dataset(state.dataset_path)
prompt = f"""
You are the Data Profiler Agent.
Produce a JSON analysis plan with:
- task_type: "classification"|"regression"|"eda_only"
- target_column (if any)
- eda_steps (list)
- charts_to_make (list) # 5-10 max, most informative
- baseline_model_steps (list if modeling)
- risks_or_data_issues (list)
Dataset profile:
{json.dumps(profile, indent=2)}
"""
resp = gemini_call(prompt, thinking_level="high")
text = resp["generations"][0]["text"]
try:
plan = json.loads(text)
except:
plan = {"raw_plan": text}
state.profile = profile
state.plan = plan
return state
智能体 2: 代码编写者 (Code Writer)
这个智能体负责将分析计划转换成可执行的 Python 代码。它会接收数据集概览、分析计划以及任何之前执行时产生的错误信息。利用所有这些上下文，它会要求 LLM 只输出 Python 代码。
提示词中包含了严格的要求：加载数据集、严格遵循计划、生成所有指定的图表、将图表保存到 ARTIFACTS_DIR、跟踪文件路径和图表元数据、捕获控制台输出、保存图表后关闭图形，并选择性地计算建模指标。
这样做能确保代码在沙盒中是可复现且安全的。生成的结果会存储在 state.code 中，等待执行器运行。
@traceable(name="code_writer_agent")
def code_writer_agent(state: State):
prompt = f"""
You are the Code Writer Agent.
Write Python code ONLY (no markdown).
Previous error to fix (if any):
{state.last_error}
HARD REQUIREMENTS:
1. Load dataset from: {state.dataset_path}
2. Follow the plan exactly.
3. Create ALL charts in charts_to_make.
4. Save every chart in ARTIFACTS_DIR with filenames like:
ARTIFACTS_DIR / "chart_01_<short_name>.png"
5. Track saved plot paths in _artifacts (list[str]).
6. Track chart metadata in _charts_meta (list[dict]) with:
{{
"title": "<human readable chart title>",
"filename": "artifacts/chart_01_x.png",
"description": "<what this plot shows (1-2 sentences)>",
"one_liner": "<ONE line insight from the chart>"
}}
The one_liner MUST be a single sentence, max ~20 words.
7. Store useful console output in _stdout.
IMPORTANT:
- import matplotlib.pyplot as plt
- plt.close() after saving each plot
- ensure _artifacts and _charts_meta exist even if empty
- if modeling, add baseline metrics to _stdout
Dataset profile:
{json.dumps(state.profile, indent=2)}
Analysis plan:
{json.dumps(state.plan, indent=2)}
Return ONLY executable python code.
"""
resp = gemini_call(prompt, thinking_level="high")
state.code = resp["generations"][0]["text"]
return state
智能体 3: 执行器 (带自动重试功能)
这个智能体使用隔离的 run_python 沙盒来运行由代码编写者生成的 Python 代码。它会捕获执行结果、图表元数据、标准输出以及创建的任何“产物”。
如果代码成功运行，结果会被存储，工作流正常推进。如果失败，智能体则会增加重试计数器并存储堆栈跟踪信息，以便代码编写者智能体在下次尝试时修复错误。
通过 MAX_RETRIES 来限制循环次数，这个智能体可以避免无限循环，并提供自我修正所需的反馈信号。
@traceable(name="executor_agent")
def executor_agent(state: State):
result = run_python(state.code)
state.exec_result = result
state.charts_meta = result.get("charts_meta", [])
if not result["ok"]:
state.retry_count += 1
state.last_error = result.get("traceback", "Unknown error")
return state
智能体 4: 洞察编写者 (Insights Writer)
这个智能体负责解读整个分析过程。它会接收数据集概览、执行输出和图表元数据，然后生成人类可读的分析洞察。
它会指示 LLM 生成结构化的洞察：对于每张图表，生成两个结论和一个潜在风险，然后再生成一组有限的总体洞察。
智能体必须确保没有空的项目，没有重复的观点，并且洞察必须具体到当前的数据集，不能是泛泛而谈的。
最终生成的洞察报告会存储在 state.insights 中，作为最终报告阶段的输入。
@traceable(name="insights_agent")
def insights_agent(state: State):
prompt = f"""
You are the Insights Agent.
HARD REQUIREMENTS:
- No empty bullets.
- No repeated bullets.
- Be specific to this dataset and these charts.
- Output format:
### Chart Insights
For each chart in charts_meta:
- **<title>**
- Takeaway 1 (one sentence)
- Takeaway 2 (one sentence)
- Caveat/Risk (one sentence)
### Overall Insights
- 3-5 bullets max, each one sentence.
Inputs:
Profile:
{json.dumps(state.profile, indent=2)}
Execution result:
{json.dumps(state.exec_result, indent=2)}
Charts meta:
{json.dumps(state.charts_meta, indent=2)}
"""
resp = gemini_call(prompt, thinking_level="high")
state.insights = resp["generations"][0]["text"]
return state
5. 报告生成器 → PDF (Report Builder → PDF)
这是最终的整合智能体。它会利用管道的全部输出：概览、洞察、图表元数据、执行日志，然后生成一份完整、干净的 Markdown 报告。
提示词会强制执行严格的格式规则：没有重复的标题、一致的间距、每张图表都以标准化的 HTML 块精确展示一次，以及洞察信息被整洁地整合进来。
Markdown 生成后，智能体就会调用 render_pdf 函数，使用 WeasyPrint 将其转换成精美的 PDF 文件。Markdown 和 PDF 路径都会存储在共享状态中，至此，整个分析工作流便告一段落。
@traceable(name="report_agent")
def report_agent(state: State):
prompt = f"""
You are the Report Agent.
Create a neat Markdown report (HTML allowed).
HARD REQUIREMENTS:
- Do NOT repeat section titles or chart titles.
- Do NOT output empty bullet points. If a bullet would be empty, skip it.
- Keep spacing consistent: one blank line between sections.
- Use charts_meta as the ONLY source of charts.
- Include EVERY chart, exactly once, in the same order as charts_meta.
- For each chart output EXACTLY this block:
<div class="chart-block">
<h3>Chart {{i}}: {{title}}</h3>
<img src="{{filename}}" alt="{{title}}">
<p><b>What it shows:</b> {{one_liner}}</p>
</div>
Where:
- title, filename, one_liner come from charts_meta
- one_liner must be ONE sentence, max ~20 words.
Sections:
1. Dataset Overview (short)
2. Data Quality Notes (bullets)
3. Exploratory Analysis (chart-by-chart blocks only, no extra chart titles)
4. Modeling Results (if any; use a markdown table)
5. Key Insights (use insights text)
6. Recommendations / Next Steps (bullets)
Inputs:
Profile: {json.dumps(state.profile, indent=2)}
Exec stdout: {state.exec_result.get("stdout","")}
Exec ok: {state.exec_result.get("ok")}
Traceback (if any): {state.exec_result.get("traceback","")}
Charts meta:
{json.dumps(state.charts_meta, indent=2)}
Insights:
{state.insights}
Return ONLY the Markdown report.
"""
resp = gemini_call(prompt, thinking_level="low")
state.report_md = resp["generations"][0]["text"]
state.report_pdf = render_pdf(state.report_md)
return state
6. 构建多智能体图谱
最后一步是构建完整的多智能体工作流，我们将所有智能体组合成一个状态驱动的图谱。
我们使用共享的 State 模型创建了一个 StateGraph，这确保了随着工作流的推进，每个智能体都能与同一个不断演进的状态对象进行交互。每个组件，比如概览器、代码编写器、执行器、洞察编写器和报告生成器，都被作为独立的节点添加到图中，代表了管道中的一个特定阶段。
工作流总是从概览智能体开始，它被指定为入口点。这保证了整个过程始于对数据集的全面理解和分析计划的生成。
我们通过“边”来定义流程的走向。在概览之后，输出会指向代码编写器，然后代码编写器再将结果传递给执行器。关键的逻辑在于执行器之后的条件路由。
一个辅助函数 retry_or_continue 会检查执行结果。如果代码执行成功，工作流会继续到洞察智能体。
如果执行失败但还有重试次数，它会循环回代码编写器进行自动修正。
假如没有剩余的重试次数了，它就会跳过后续分析，直接进入报告生成器，这样就能防止系统陷入无限循环。这些条件边被整合到执行器节点中，所以工作流可以根据执行的成功与否进行调整。
最后，图谱将洞察阶段连接到报告阶段，再从报告阶段连接到工作流的结束。然后图谱被编译成一个可执行的结构，并生成一个 ASCII 图来可视化整个流程。
这个多智能体图谱协调了整个自适应分析管道，实现了错误恢复、步骤协调以及智能体之间的顺畅过渡。
g = StateGraph(State)
g.add_node("profiler", profiler_agent)
g.add_node("code_writer", code_writer_agent)
g.add_node("executor", executor_agent)
g.add_node("insights", insights_agent)
g.add_node("report", report_agent)
g.set_entry_point("profiler")
g.add_edge("profiler", "code_writer")
g.add_edge("code_writer", "executor")
def retry_or_continue(state: State):
# success path
if state.exec_result and state.exec_result.get("ok"):
return "insights"
# stop retrying after MAX_RETRIES
if state.retry_count >= MAX_RETRIES:
return "report"
return "code_writer"
g.add_conditional_edges(
"executor",
retry_or_continue,
{"code_writer": "code_writer", "insights": "insights", "report": "report"}
)
g.add_edge("insights", "report")
g.add_edge("report", END)
graph = g.compile()
print(graph.get_graph().draw_ascii())
这段代码会打印出图谱的 ASCII 示意图：
+-----------+
| __start__ |
+-----------+
*
*
*
+-----------+
| profiler |
+-----------+
*
*
*
+-------------+
| code_writer |
+-------------+
.
.
.
+-----------+
| executor |
+-----------+
.. ..
.. ..
. ..
+-----------+ .
| insights | ..
+-----------+ ..
** ..
** ..
* .
+--------+
| report |
+--------+
*
*
*
+-----------+
| __end__ |
+-----------+
7. 运行完整的 Gemini 3 API 数据分析管道
要运行整个管道，你只需要提供一个数据集路径，创建一个初始的 State 对象，然后调用编译好的图谱。我这里使用的是著名的 Boston Housing 数据集作为例子。
DATASET_PATH = "/work/housing.csv" # <-- change this
state = State(dataset_path=DATASET_PATH)
out = graph.invoke(state)
一旦被调用，这个多智能体系统就会自动完成整个分析过程：概览数据集、生成计划、编写并执行 Python 代码、提取洞察，然后生成 Markdown 和 PDF 两种格式的报告。
--- Modeling Baseline Results ---
Dataset Shape: (489, 4)
Linear Regression -> RMSE: 82,395.54, R2: 0.6911
Random Forest -> RMSE: 56,931.38, R2: 0.8525
Observations: Random Forest typically outperforms Linear Regression due to capturing non-linear relationships (e.g., LSTAT).
运行结束后，你可以打开 LangSmith 仪表板，导航到“autolab-gemini3pro”项目。每一次智能体运行都会在那里显示。
点击最近的一次运行，切换到“Waterfall”视图，你会看到每个步骤的时间线：智能体花了多久时间，以及它们使用了哪些工具。
你还可以点击任何一个智能体，查看它的详细信息：
- 它接收到的提示词
- 模型生成的具体内容
- 工具执行详情
- 返回的产物、图表和追踪信息
我个人觉得，LangSmith 在改进整个工作流方面简直功不可没。大家现在看到的是最终版，但为了让这个项目运作起来，我可是经历了不少尝试，LangSmith 帮我调试解决了智能体中遇到的各种问题。
8. 显示报告 Markdown 和 PDF
多智能体工作流完成后，你可以在 Jupyter Notebook 中直接检查生成的 Markdown 报告。
Markdown 版本对于快速回顾分析、阅读洞察和检查报告结构非常有用，而且你无需离开当前的开发环境。
print(out["report_md"][:2000])
# Housing Price Analysis Report
## 1. Dataset Overview
The dataset consists of **489** records and **4** features focusing on housing metrics. The target variable is `MEDV` (Median Value of owner-occupied homes). The features include `RM` (average number of rooms), `LSTAT.................`
除了 Markdown 版本，工作流还会生成一份精美的 PDF 报告。PDF 文件会自动保存在 artifacts 文件夹中，你可以这样查看路径：
print("PDF saved at:", out["report_pdf"])
PDF saved at: artifacts/report.pdf
生成的 PDF 报告非常完善，包含了分析的所有关键部分：叙述性解释、渲染好的图表、图表解读、建模总结和最终建议。
这使得它成为与团队成员、主管或客户分享的理想选择，特别是当你需要一份清晰、可供演示的结果版本时。
总结
在开发这个项目的过程中，我真切感受到了现代 AI 模型和基于图谱的智能体工作流发展有多迅速。就在不久前，哪怕只是构建一个带多个工具的智能体，都需要数天时间进行调优、调试，还得应对各种不可预测的行为。
如今，有了像 Gemini 3 Pro 这样的模型，系统能够非常可靠地理解数据集、生成准确的代码、运行分析、解读可视化结果，并整合出一份精美的报告。这其中的进步，着实令人惊叹。
在这个项目里，我们搭建了一个完整的，多智能体驱动的数据分析应用。它能接收任意 CSV 数据集，执行端到端的探索性分析，运行基线模型，生成洞察，并产出格式完整的 PDF 报告。
这个项目由五个相互协作的智能体构成，它们分别是：概览与规划、代码生成、带重试机制的执行、洞察生成以及报告输出。同时，它也用到了三个核心工具，用于加载数据集、安全执行代码和将 Markdown 渲染为 PDF。
最终，我们得到了一个整洁、自动化的分析流程，它能生成一份专业的、带有叙述性的报告，并辅以直观的可视化图表。
关于
关注我获取更多资讯
