0
0
0

从零开始理解技术探索与实践：Ollama与Agentic AI实战指南

分支开太多了
2026-07-25 05:55
阅读 263

写在前面的话：作为一名开源项目的维护者，我写过无数技术文档，但始终觉得最好的文档是"能让人真正动手做起来"的教程。我当初学这些技术的时候，踩了太多坑，看了太多晦涩难懂的官方文档。所以这篇教程，我想用最简单的话，带你从零开始，真正跑通 Ollama 和 Agentic AI 的完整链路。

一、开篇：我们在聊什么？

1.1 先搞清楚两个核心概念

在开始写代码之前，我们先花几分钟把概念理清楚。别急，我用最通俗的话来说。

Ollama 是什么？

想象一下，你想在本地电脑上运行一个大语言模型（比如 Llama、Mistral、Qwen），以前你需要配 CUDA、装 PyTorch、调各种参数，折腾半天可能还跑不起来。Ollama 就是来解决这个问题的——它让你像用 Docker 拉镜像一样，一条命令就能把模型跑起来。

用一句话总结：Ollama 是一个本地大模型运行工具，让你在自己的电脑上就能跑 AI 模型，不需要联网，不需要付费，不需要复杂配置。

Agentic AI 是什么？

传统的 AI 应用是这样的：你问一个问题，AI 给你一个回答，结束。这叫"一问一答"模式。

而 Agentic AI（智能体 AI）不一样。它更像是一个"有自主行动能力的助手"。它不只是回答问题，它还能：

  • 自己拆解任务
  • 调用外部工具（搜索、计算、查数据库）
  • 根据中间结果调整策略
  • 多步骤完成复杂任务

举个例子：你说"帮我查一下最近一周 GitHub 上最火的 Python 项目，然后写一份报告"。传统 AI 可能只能给你一个大概的回答。而 Agentic AI 会自己去调用 GitHub API 查数据，自己分析趋势，自己组织语言写报告。

用一句话总结：Agentic AI 是能自主规划、调用工具、多步执行任务的 AI 系统。

1.2 为什么要把这两个放在一起学？

因为 Ollama 提供了本地模型运行的能力，而 Agentic AI 框架（比如 LangChain、CrewAI）需要调用大模型。把它们结合起来，你就能在本地搭建一个完整的、不依赖外部 API 的智能体系统。

这对于学习和实践来说太重要了：

  • 不用担心 API 额度用完
  • 不用担心数据隐私泄露
  • 可以随意调试和实验
  • 完全免费

二、环境准备：工欲善其事

2.1 硬件要求

先说清楚，本地跑大模型对硬件是有要求的。我整理了一个表格：

硬件配置 最低要求 推荐配置 能跑的模型
内存（RAM） 8GB 16GB+ 7B 参数模型
内存（RAM） 16GB 32GB+ 13B 参数模型
内存（RAM） 32GB+ 64GB+ 70B 参数模型
GPU 无（用CPU） NVIDIA 8GB+ VRAM 速度差异巨大
磁盘空间 10GB 50GB+ 模型文件较大

我当初学的时候，用一台 8GB 内存的笔记本跑 7B 模型，CPU 推理慢到怀疑人生。后来换了台有显卡的机器，速度直接起飞。所以如果条件允许，尽量用有 NVIDIA 显卡的机器。

2.2 安装 Ollama

macOS 用户：

# 方法一：官网下载安装包
# 访问 https://ollama.com/download 下载 .zip 文件，解压后拖入 Applications

# 方法二：使用 Homebrew
brew install ollama

Linux 用户：

# 一键安装脚本
curl -fsSL https://ollama.com/install.sh | sh

Windows 用户：

# 访问 https://ollama.com/download 下载安装包
# 双击安装，一路 Next 即可

2.3 验证安装

安装完成后，打开终端验证：

# 检查 Ollama 版本
ollama --version

# 启动 Ollama 服务（如果没自动启动的话）
ollama serve

你应该能看到类似这样的输出：

time=2024-01-15T10:00:00.000+08:00 level=INFO source=images.go:717 msg="total blobs: 0"
time=2024-01-15T10:00:00.000+08:00 level=INFO source=routes.go:1080 msg="Listening on 127.0.0.1:11434"

2.4 下载第一个模型

# 下载并运行 qwen2.5:7b 模型（推荐中文能力好的模型）
ollama run qwen2.5:7b

第一次运行会自动下载模型文件，大概 4-5GB，耐心等待。下载完成后会直接进入对话模式：

>>> 你好，请介绍一下你自己
我是通义千问（Qwen），由阿里巴巴集团通义实验室自主研发...

输入 /bye 退出对话模式。

2.5 安装 Python 开发环境

后面我们要用 Python 来构建 Agentic AI，所以需要准备 Python 环境：

# 确认 Python 版本（需要 3.9+）
python3 --version

# 创建虚拟环境
mkdir agentic-ai-demo
cd agentic-ai-demo
python3 -m venv venv

# 激活虚拟环境
# macOS/Linux:
source venv/bin/activate
# Windows:
venv\Scripts\activate

# 安装核心依赖
pip install langchain langchain-ollama langchain-community

三、核心概念：用大白话讲清楚

3.1 Ollama 的 API 工作原理

Ollama 启动后，会在本地 127.0.0.1:11434 上跑一个 HTTP 服务。你可以把它理解成一个"本地版的 OpenAI API"。

它提供两个核心接口：

接口 路径 用途
生成接口 /api/generate 单次文本生成
对话接口 /api/chat 多轮对话（带上下文）

你可以用 curl 直接测试：

# 测试生成接口
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:7b",
  "prompt": "用一句话解释什么是人工智能",
  "stream": false
}'

3.2 Agentic AI 的核心组成

一个 Agentic AI 系统通常包含以下几个部分，我用一个"餐厅"的比喻来解释：

┌─────────────────────────────────────────────────┐
│                  Agentic AI 系统                  │
│                                                   │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐   │
│  │  大脑     │───▶│  规划器   │───▶│  执行器   │   │
│  │ (LLM)    │    │(Planner) │    │(Executor)│   │
│  └──────────┘    └──────────┘    └──────────┘   │
│       │                                │          │
│       │          ┌──────────┐          │          │
│       └─────────▶│  记忆     │◀─────────┘          │
│                  │ (Memory) │                      │
│                  └──────────┘                      │
│                       │                            │
│                  ┌──────────┐                      │
│                  │  工具箱   │                      │
│                  │ (Tools)  │                      │
│                  └──────────┘                      │
└─────────────────────────────────────────────────┘
  • 大脑（LLM）：就是 Ollama 跑的模型，负责理解和推理
  • 规划器（Planner）：把复杂任务拆解成小步骤
  • 执行器（Executor）：一步步执行每个小步骤
  • 记忆（Memory）：记住之前做过什么，避免重复
  • 工具箱（Tools）：可以调用的外部能力，比如搜索、计算、查数据库

3.3 LangChain 是什么？

LangChain 是目前最流行的 LLM 应用开发框架。它帮你把上面那些组件串起来。你不需要从零写所有逻辑，LangChain 提供了现成的抽象。

核心概念对应关系：

Agentic AI 概念 LangChain 对应 说明
大脑 ChatOllama 封装了 Ollama 的对话接口
工具箱 Tool 定义可调用的工具函数
执行器 Agent 负责决策和调用工具
记忆 Memory 保存对话历史

四、实战项目：构建你的第一个本地智能体

4.1 项目目标

我们要做一个"智能研究助手"，它能：

  1. 接收用户的研究问题
  2. 自动拆解为子任务
  3. 调用工具（模拟搜索、计算）
  4. 汇总结果给出最终答案

4.2 第一步：连接 Ollama

创建文件 agent_demo.py：

from langchain_ollama import ChatOllama

# 初始化本地模型
llm = ChatOllama(
    model="qwen2.5:7b",
    temperature=0,        # 温度越低，输出越确定
    num_predict=2048,     # 最大输出 token 数
)

# 测试一下
response = llm.invoke("你好，请用一句话介绍自己")
print(response.content)

运行测试：

python agent_demo.py

如果能看到模型的回复，说明连接成功。

新手常见问题：如果报错 Connection refused，检查 Ollama 服务是否在运行。执行 ollama serve 启动服务。

4.3 第二步：定义工具

工具是 Agentic AI 的"手脚"。我们来定义几个实用工具：

from langchain.tools import tool
import json
from datetime import datetime

# 工具1：模拟搜索
@tool
def web_search(query: str) -> str:
    """根据关键词搜索网络信息。输入搜索关键词，返回搜索结果。"""
    # 实际项目中这里会调用真实的搜索 API
    # 这里我们用模拟数据演示
    mock_results = {
        "python": "Python 是一种高级编程语言，以简洁易读著称。2024年最新版本为 3.12。",
        "ai": "人工智能（AI）是计算机科学的一个分支，致力于创建能执行通常需要人类智能的任务的系统。",
        "ollama": "Ollama 是一个开源工具，允许用户在本地运行大型语言模型，支持 macOS、Linux 和 Windows。",
    }
    
    # 简单匹配
    for key, value in mock_results.items():
        if key in query.lower():
            return f"搜索结果：{value}"
    
    return f"搜索结果：未找到与 '{query}' 直接相关的信息，建议换个关键词试试。"

# 工具2：计算器
@tool
def calculator(expression: str) -> str:
    """计算数学表达式。输入数学表达式（如 '2 + 3 * 4'），返回计算结果。"""
    try:
        # 安全地计算数学表达式
        allowed_chars = set("0123456789+-*/.() ")
        if not all(c in allowed_chars for c in expression):
            return "错误：表达式包含不允许的字符"
        result = eval(expression)
        return f"计算结果：{expression} = {result}"
    except Exception as e:
        return f"计算错误：{str(e)}"

# 工具3：获取当前时间
@tool
def get_current_time(dummy: str = "") -> str:
    """获取当前日期和时间。"""
    now = datetime.now()
    return f"当前时间：{now.strftime('%Y年%m月%d日 %H:%M:%S')}"

4.4 第三步：创建 Agent

这是核心部分。我们把 LLM 和工具组合成一个有自主决策能力的 Agent：

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

# 把所有工具收集起来
tools = [web_search, calculator, get_current_time]

# 定义 Agent 的系统提示词
system_prompt = """你是一个智能研究助手。你的任务是帮助用户解答问题。

你可以使用以下工具：
- web_search: 搜索网络信息
- calculator: 进行数学计算
- get_current_time: 获取当前时间

工作原则：
1. 仔细分析用户的问题，判断是否需要使用工具
2. 如果需要多个工具，按顺序调用
3. 整合工具返回的结果，给出完整、准确的回答
4. 如果工具返回的信息不够，可以尝试用不同关键词再次搜索
5. 用中文回答所有问题
"""

# 构建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

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

# 包装成 AgentExecutor
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,           # 打印详细的执行过程
    max_iterations=5,       # 最多迭代5次，防止死循环
    handle_parsing_errors=True,  # 自动处理解析错误
)

4.5 第四步：运行 Agent

def chat(user_input: str):
    """与 Agent 对话的主函数"""
    print(f"\n{'='*50}")
    print(f"用户：{user_input}")
    print(f"{'='*50}")
    
    result = agent_executor.invoke({"input": user_input})
    
    print(f"\n{'='*50}")
    print(f"助手：{result['output']}")
    print(f"{'='*50}\n")
    
    return result["output"]

# 测试几个场景
if __name__ == "__main__":
    # 场景1：简单问答（不需要工具）
    chat("什么是人工智能？")
    
    # 场景2：需要搜索工具
    chat("帮我搜索一下 Ollama 是什么")
    
    # 场景3：需要计算工具
    chat("帮我算一下 (123 + 456) * 789 等于多少")
    
    # 场景4：组合使用多个工具
    chat("现在是几点？另外帮我算一下 3.14 * 100 等于多少")

4.6 完整代码

把上面所有代码整合在一起，这就是你的完整文件：

"""
本地 Agentic AI 演示
依赖：pip install langchain langchain-ollama langchain-community
前置：ollama serve && ollama pull qwen2.5:7b
"""

from langchain_ollama import ChatOllama
from langchain.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from datetime import datetime

# ============ 1. 初始化模型 ============
llm = ChatOllama(
    model="qwen2.5:7b",
    temperature=0,
    num_predict=2048,
)

# ============ 2. 定义工具 ============
@tool
def web_search(query: str) -> str:
    """根据关键词搜索网络信息。输入搜索关键词，返回搜索结果。"""
    mock_results = {
        "python": "Python 是一种高级编程语言，以简洁易读著称。2024年最新版本为 3.12。",
        "ai": "人工智能（AI）是计算机科学的一个分支，致力于创建能执行通常需要人类智能的任务的系统。",
        "ollama": "Ollama 是一个开源工具，允许用户在本地运行大型语言模型，支持 macOS、Linux 和 Windows。",
    }
    for key, value in mock_results.items():
        if key in query.lower():
            return f"搜索结果：{value}"
    return f"搜索结果：未找到与 '{query}' 直接相关的信息。"

@tool
def calculator(expression: str) -> str:
    """计算数学表达式。输入数学表达式（如 '2 + 3 * 4'），返回计算结果。"""
    try:
        allowed_chars = set("0123456789+-*/.() ")
        if not all(c in allowed_chars for c in expression):
            return "错误：表达式包含不允许的字符"
        result = eval(expression)
        return f"计算结果：{expression} = {result}"
    except Exception as e:
        return f"计算错误：{str(e)}"

@tool
def get_current_time(dummy: str = "") -> str:
    """获取当前日期和时间。"""
    now = datetime.now()
    return f"当前时间：{now.strftime('%Y年%m月%d日 %H:%M:%S')}"

tools = [web_search, calculator, get_current_time]

# ============ 3. 创建 Agent ============
system_prompt = """你是一个智能研究助手。你可以使用工具来帮助用户。
工作原则：
1. 分析问题，判断是否需要工具
2. 整合工具结果，给出完整回答
3. 用中文回答"""

prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5,
    handle_parsing_errors=True,
)

# ============ 4. 运行 ============
def chat(user_input: str):
    print(f"\n{'='*50}")
    print(f"用户：{user_input}")
    result = agent_executor.invoke({"input": user_input})
    print(f"\n助手：{result['output']}")
    print(f"{'='*50}\n")
    return result["output"]

if __name__ == "__main__":
    chat("帮我搜索一下 Ollama 是什么")
    chat("帮我算一下 (123 + 456) * 789 等于多少")
    chat("现在是几点？帮我算一下 3.14 * 100")

4.7 运行效果

执行 python agent_demo.py，你会看到类似这样的输出（verbose 模式会打印 Agent 的思考过程）：

==================================================
用户：帮我搜索一下 Ollama 是什么
==================================================

> Entering new AgentExecutor chain...

> Invoking: `web_search` with `{'query': 'Ollama'}`

> 搜索结果：Ollama 是一个开源工具，允许用户在本地运行大型语言模型...

> Ollama 是一个开源工具，允许用户在本地运行大型语言模型，支持 macOS、Linux 和 Windows。

==================================================
助手：Ollama 是一个开源工具，允许用户在本地运行大型语言模型，支持 macOS、Linux 和 Windows。
==================================================

五、进阶：给 Agent 加上记忆

上面的 Agent 是"无状态"的，每次对话都是独立的。我们来加上记忆功能，让它能记住之前的对话。

5.1 使用 RunnableWithMessageHistory

from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.runnables.history import RunnableWithMessageHistory

# 用字典存储会话历史（实际项目中应该用数据库）
session_store = {}

def get_session_history(session_id: str):
    if session_id not in session_store:
        session_store[session_id] = []
    return session_store[session_id]

# 包装 Agent，加上历史记录
agent_with_memory = RunnableWithMessageHistory(
    agent_executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

# 测试多轮对话
config = {"configurable": {"session_id": "user_001"}}

# 第一轮
result1 = agent_with_memory.invoke(
    {"input": "我叫小明，我是一名程序员"},
    config=config,
)
print(f"第一轮回复：{result1['output']}")

# 第二轮（Agent 应该记住用户的名字）
result2 = agent_with_memory.invoke(
    {"input": "你还记得我叫什么名字吗？"},
    config=config,
)
print(f"第二轮回复：{result2['output']}")

5.2 运行效果

第一轮回复：你好小明！很高兴认识你，程序员同行...
第二轮回复：你叫小明，你是一名程序员...

六、我对技术探索与实践的看法

写到这里，教程的技术部分基本结束了。但我想花一些篇幅，聊聊我在技术探索和实践过程中的一些思考。这些不是技术知识，而是我作为开源项目维护者的一些心得。

6.1 "跑通"比"完美"重要一万倍

我当初学这些技术的时候，最大的教训就是：不要一开始就追求完美架构。

很多人（包括曾经的我）会花大量时间纠结：

  • 该用哪个框架？
  • 架构怎么设计最优雅？
  • 代码结构怎么组织最好？

但事实是：先跑通，再优化。

你先把 Ollama 装好，模型跑起来，Agent 能对话，这就已经超过了 80% 只看不做的人。然后在跑通的基础上，一步步优化。

我的建议是遵循这个路径：

第一步：跑通最小可用版本（本文教程就是这个）
    ↓
第二步：理解每一行代码在做什么
    ↓
第三步：加入自己的需求和改动
    ↓
第四步：优化性能和架构
    ↓
第五步：开源或投入生产

6.2 本地优先：为什么我推荐从 Ollama 开始

很多教程一上来就教你调 OpenAI API、Claude API。这当然没问题，但我强烈建议初学者从本地模型开始，原因如下：

对比维度 本地模型（Ollama） 云端 API（OpenAI等）
费用 完全免费 按 token 计费
隐私 数据不出本机 数据上传到云端
调试 可以随意实验 每次调用都花钱，不敢乱试
速度 取决于硬件 取决于网络和服务器
模型能力 弱于顶级云端模型 最强模型 available
学习价值 理解模型运行机制 只学会调 API

本地模型最大的优势是"零成本试错"。 你可以随意修改参数、换模型、做各种疯狂实验，不用担心账单。这种自由度对于学习来说太重要了。

6.3 Agentic AI 的本质是"工程思维"

很多人觉得 Agentic AI 很神秘，其实它的本质就是工程思维：

  1. 任务分解：把大问题拆成小问题
  2. 工具调用：每个小问题用最合适的工具解决
  3. 结果整合：把小问题的答案组合成大问题的答案
  4. 错误处理：某一步出错了怎么办？重试？换方法？

这些不是什么高深的 AI 理论，这就是软件工程中每天都在做的事情。只不过现在我们把"决策"这一步交给了 LLM。

所以，学好 Agentic AI 的关键不是"懂多少 AI 理论"，而是"工程能力有多强"。你的系统设计能力、错误处理能力、抽象能力，直接决定了你的 Agent 有多好用。

6.4 开源社区是最好的老师

作为一个开源项目维护者，我最大的感受是：读源码比读文档有用十倍。

当你跑通了教程，想进一步深入的时候，我建议你：

  1. 去 GitHub 上找 Ollama 的源码，看看它是怎么管理模型的
  2. 读 LangChain 的源码，理解 Agent 的执行流程
  3. 看优秀的开源项目（如 AutoGPT、CrewAI）是怎么设计 Agent 的
# 克隆 Ollama 源码
git clone https://github.com/ollama/ollama.git

# 克隆 LangChain 源码
git clone https://github.com/langchain-ai/langchain.git

不需要看懂每一行代码，先理解整体架构，再深入你感兴趣的部分。

6.5 避坑指南：新手最容易犯的错

根据我维护开源项目的经验，新手最容易踩这些坑：

坑1：模型选太大，跑不动

# ❌ 错误：8GB 内存直接跑 70B 模型
ollama run llama3:70b   # 直接卡死

# ✅ 正确：从小模型开始
ollama run qwen2.5:7b   # 流畅运行

坑2：temperature 设置不合理

# ❌ 错误：temperature 太高，输出随机性太大
llm = ChatOllama(model="qwen2.5:7b", temperature=1.5)

# ✅ 正确：Agent 场景建议低 temperature
llm = ChatOllama(model="qwen2.5:7b", temperature=0)

坑3：工具描述不清晰

# ❌ 错误：描述太模糊，Agent 不知道什么时候该用
@tool
def search(query: str) -> str:
    """搜索"""
    pass

# ✅ 正确：描述清晰，包含输入输出说明
@tool
def web_search(query: str) -> str:
    """根据关键词搜索网络信息。输入搜索关键词，返回搜索结果摘要。"""
    pass

坑4：不设置 max_iterations

# ❌ 错误：不设上限，Agent 可能死循环
agent_executor = AgentExecutor(agent=agent, tools=tools)

# ✅ 正确：设置合理的迭代上限
agent_executor = AgentExecutor(
    agent=agent, tools=tools, max_iterations=5
)

七、常见问题解答

Q1：Ollama 支持哪些模型？

Ollama 支持大量开源模型，常用的有：

模型 参数量 特点 推荐场景
qwen2.5 7B/14B/72B 中文能力强 中文任务首选
llama3 8B/70B Meta 出品，综合能力强 英文任务
mistral 7B 法国 Mistral AI 出品 轻量级任务
deepseek-r1 7B/14B/32B/70B 推理能力强 数学/逻辑推理
phi3 3.8B 微软出品，小但强 低配机器

查看完整列表：

# 查看所有可用模型
ollama list

# 从 Ollama 模型库搜索
# 访问 https://ollama.com/library

Q2：Agent 总是调用错误的工具怎么办？

这通常是因为工具描述不够清晰。改进方法：

  1. 工具函数名要有意义（web_search 比 tool1 好）
  2. docstring 要详细说明输入输出
  3. 在系统提示词中明确说明每个工具的用途
  4. 给 Agent 提供使用示例

Q3：本地模型回答质量不如云端模型怎么办？

这是正常的。本地小模型的能力确实不如 GPT-4、Claude 这些顶级模型。但你可以：

  1. 用更好的提示词（Prompt Engineering）
  2. 换更强的本地模型（如 72B 的 Qwen）
  3. 把复杂推理任务拆得更细
  4. 用 RAG（检索增强生成）补充知识

Q4：如何让 Agent 支持流式输出？

# 流式输出配置
for chunk in agent_executor.stream({"input": "你好"}):
    if "output" in chunk:
        print(chunk["output"], end="", flush=True)

Q5：Ollama 可以同时跑多个模型吗？

可以，但受限于内存。你可以同时加载多个模型：

# 同时拉取多个模型
ollama pull qwen2.5:7b
ollama pull llama3:8b

# 在代码中切换模型
llm_qwen = ChatOllama(model="qwen2.5:7b")
llm_llama = ChatOllama(model="llama3:8b")

八、学习建议：下一步怎么走

恭喜你读到这里！你已经完成了从零到一的过程。接下来，我建议你按以下路径继续深入：

8.1 短期（1-2周）

  • 把教程代码跑通，确保每个步骤都能正常运行
  • 尝试修改工具，加入真实的功能（比如调用真实的搜索 API）
  • 换不同的模型，对比效果差异
  • 阅读 LangChain 官方文档中关于 Agent 的部分

8.2 中期（1-2月）

  • 学习 RAG（检索增强生成），给 Agent 加上知识库
  • 了解 CrewAI 或 AutoGen 等多 Agent 框架
  • 尝试构建一个有实际用途的应用（比如代码审查助手、文档生成器）
  • 学习如何评估 Agent 的效果

8.3 长期（3-6月）

  • 深入理解 Transformer 架构和 LLM 原理
  • 学习模型微调（Fine-tuning），让模型更适应你的场景
  • 关注 Agentic AI 的最新研究进展
  • 参与开源项目，贡献代码

8.4 推荐资源

资源类型 名称 链接
官方文档 Ollama 文档 https://github.com/ollama/ollama
官方文档 LangChain 文档 https://python.langchain.com
开源项目 CrewAI https://github.com/joaomdmoura/crewAI
开源项目 AutoGen https://github.com/microsoft/autogen
学习平台 Hugging Face https://huggingface.co

九、总结

回顾一下我们今天学到的内容：

  1. Ollama 让你能在本地免费运行大语言模型，是学习 AI 的最佳起点
  2. Agentic AI 是能自主规划、调用工具、多步执行任务的 AI 系统
  3. 我们用 LangChain + Ollama 构建了一个完整的本地智能体
  4. 技术探索的核心是先跑通再优化，不要追求一步到位

我当初学这些技术的时候，最大的感悟就是：动手做比什么都重要。 看十篇教程不如自己写一遍代码。所以，如果你还没动手，现在就去把教程代码跑起来吧。

最后，技术探索是一场马拉松，不是短跑。保持好奇心，保持动手的习惯，你会走得越来越远。

祝你在 AI 的世界里玩得开心！

关于作者：我是一名开源项目维护者，长期活跃在 AI 和开发者工具领域。如果你对本教程有任何疑问，欢迎在评论区交流。如果觉得有帮助，别忘了点赞收藏，你的支持是我持续创作的动力。

标签:OllamaAgentic AI

评论 0

最热最新
暂无评论

为你推荐

暂无相关推荐
分支开太多了Lv.1
0
影响力
0
文章
0
粉丝

相关推荐

暂无相关推荐

精选内容

暂无精选内容