基于Zigent框架的DeepSeek智能体完全开发指南

前言

Hello，大家好，我是GISer Liu😁，一名热爱AI技术的GIS开发者。本系列是作者参加DataWhale 2025年2月份组队学习的技术笔记文档，这里整理为博客，希望能帮助学习Agent的开发者少走弯路！

一、Zigent是什么？

1.介绍

Zigent是基于Salesforce AI Research团队开发的AgentLite框架改进的智能体开发框架。它专为构建和研究基于LLM的任务导向型多Agent系统设计，具备以下核心特性：

2. zigent 和 AgentLite 有什么区别？

二、环境配置

这里我们使用conda配置环境👌

1.Conda环境配置

• 创建激活zigent环境

# 创建专用环境
conda create -n zigent python=3.9
conda activate zigent

• 安装依赖包

# 安装核心依赖
pip install zigent duckduckgo_search python-dotenv 

• 验证是否安装成功！

# 验证脚本 verify_install.py
from zigent import __version__
print(f"Zigent版本: {__version__}")

from zigent.agents import BaseAgent
print("基础Agent类加载成功！")

安装成功！🙂

三、快速入门

这里我们不讲解Agent的什么原理，我们就只说明其功能设计，要想看原理的读者可以直接看我之前的文章！🙂👌

1.配置LLM

下面是我们在根目录下创建的环境变量，各位可以直接按照这个参考：

API申请在我之前的文章都有讲解！

然后我们按照下面的代码测试模型调用是否正常！

import os
from dotenv import load_dotenv
from typing import List

# 引入 zigent 相关的方法如Action、Agent、大模型配置等以及 duckduckgo_search 
from zigent.agents import ABCAgent, BaseAgent
from zigent.llm.agent_llms import LLM
from zigent.commons import TaskPackage
from zigent.actions.BaseAction import BaseAction
from zigent.logging import AgentLogger
from duckduckgo_search import DDGS

# 加载环境变量
load_dotenv()
# 从环境变量中读取api_key
api_key = os.getenv('API_KEY')
base_url = os.getenv('BASE_URL')
chat_model = os.getenv('MODEL_NAME')

llm = LLM(api_key=api_key, base_url=base_url, model_name=chat_model)
response = llm.run("你是谁？")
print(response)

2.Action创建

在Zigent框架中，动作（Action）是智能代理执行具体任务的基本单元。每个动作都需要明确定义其元数据和行为规范。以下是每个Action定义的字段和属性：

下面是一个基于duckduckgo_search的搜索Action，我们可以调用试试：

duckduckgo_search使用时访问的是国外的服务器，因此需要科学代理才能使用，如果要用国内的，可以考虑百度AI搜索和智谱AI搜索的接口；🤔

from typing import List, Dict, Any
# 引入Zigent框架的核心组件
from zigent.actions.BaseAction import BaseAction
# 引入DuckDuckGo搜索库
from duckduckgo_search import DDGS




class SearchAction(BaseAction):
    """
    自定义搜索动作类，继承自BaseAction。
    该动作用于通过DuckDuckGo搜索引擎执行网页搜索。
    """

    def __init__(self):
        """
        初始化搜索动作。
        - 定义动作名称、描述和参数文档。
        - 初始化DuckDuckGo搜索客户端。
        """
        super().__init__(
            action_name="WebSearch",  # 动作名称
            action_desc="通过DuckDuckGo搜索引擎执行网页搜索，支持关键词查询和结果数量限制。",  # 动作描述
            params_doc={
                "query": {
                    "description": "搜索关键词，支持布尔表达式",
                    "type": "string",
                    "required": True,
                    "example": "Zigent框架使用指南"
                },
                "max_results": {
                    "description": "最大返回结果数",
                    "type": "int",
                    "required": False,
                    "default": 5,
                    "range": "1-10"
                }
            }
        )
        self.ddgs = DDGS()  # 初始化DuckDuckGo搜索客户端

    def __call__(self, query: str, max_results: int = 5) -> List[Dict[str, Any]]:
        """
        执行搜索操作。
        
        参数:
        - query: 搜索关键词（字符串）
        - max_results: 最大返回结果数（整数，默认为5）
        
        返回:
        - 搜索结果列表，每个结果是一个字典，包含标题、链接和摘要等信息。
        """
        try:
            # 调用DuckDuckGo搜索API
            results = self.ddgs.text(query, max_results=max_results)
            return results
        except Exception as e:
            # 捕获异常并返回错误信息
            return [{"error": str(e)}]



if __name__ == "__main__":
    # 初始化搜索动作
    search_action = SearchAction()

    # 测试搜索功能
    query = "Zigent框架最新版本"  # 搜索关键词
    max_results = 5  # 最大返回结果数

    # 执行搜索
    results = search_action(query, max_results=max_results)

    # 打印搜索结果
    print("搜索关键词:", query)
    print("返回结果数:", len(results))
    print("搜索结果:")
    for i, result in enumerate(results, start=1):
        print(f"\n结果 {i}:")
        print("标题:", result.get("title", "无标题"))
        print("链接:", result.get("link", "无链接"))
        print("摘要:", result.get("body", "无摘要"))

可以看到，这里搜出了多个结果！👍👍

4. Agent创建

ok,到代理了，我们直接基于上面的Action创建搜索Agent,后面解释其参数：

import os
from dotenv import load_dotenv
from typing import List, Dict, Any

# 引入Zigent框架的核心组件
from zigent.agents import BaseAgent
from zigent.llm.agent_llms import LLM
from zigent.actions.BaseAction import BaseAction
from zigent.commons import TaskPackage
from zigent.logging import AgentLogger

# 引入DuckDuckGo搜索库
from duckduckgo_search import DDGS

# 加载环境变量
load_dotenv()

# 从环境变量中读取API配置
api_key = os.getenv('API_KEY')  # 大模型API密钥
base_url = os.getenv('BASE_URL')  # 大模型服务地址
chat_model = os.getenv('MODEL_NAME')  # 使用的模型名称

# 初始化大语言模型（LLM）
llm = LLM(api_key=api_key, base_url=base_url, model_name=chat_model)

# 测试LLM连接
response = llm.run("你是谁？")
print("LLM响应:", response)




class SearchAction(BaseAction):
    """
    自定义搜索动作类，继承自BaseAction。
    该动作用于通过DuckDuckGo搜索引擎执行网页搜索。
    """

    def __init__(self):
        """
        初始化搜索动作。
        - 定义动作名称、描述和参数文档。
        - 初始化DuckDuckGo搜索客户端。
        """
        super().__init__(
            action_name="WebSearch",  # 动作名称
            action_desc="通过DuckDuckGo搜索引擎执行网页搜索，支持关键词查询和结果数量限制。",  # 动作描述
            params_doc={
                "query": {
                    "description": "搜索关键词，支持布尔表达式",
                    "type": "string",
                    "required": True,
                    "example": "Zigent框架使用指南"
                },
                "max_results": {
                    "description": "最大返回结果数",
                    "type": "int",
                    "required": False,
                    "default": 5,
                    "range": "1-10"
                }
            }
        )
        self.ddgs = DDGS()  # 初始化DuckDuckGo搜索客户端

    def __call__(self, query: str, max_results: int = 5) -> List[Dict[str, Any]]:
        """
        执行搜索操作。
        
        参数:
        - query: 搜索关键词（字符串）
        - max_results: 最大返回结果数（整数，默认为5）
        
        返回:
        - 搜索结果列表，每个结果是一个字典，包含标题、链接和摘要等信息。
        """
        try:
            # 调用DuckDuckGo搜索API
            results = self.ddgs.text(query, max_results=max_results)
            return results
        except Exception as e:
            # 捕获异常并返回错误信息，保持结构一致
            return [{"title": "错误", "link": "", "body": str(e)}]


class SearchAgent(BaseAgent):
    """
    搜索代理类，继承自BaseAgent。
    该代理用于执行搜索任务，并返回格式化后的结果。
    """

    def __init__(self, llm: LLM):
        """
        初始化搜索代理。
        
        参数:
        - llm: 大语言模型实例，用于结果格式化。
        """
        super().__init__(
            name="search_agent",  # 代理名称
            role="通过DuckDuckGo搜索引擎回答用户问题",  # 代理角色描述
            llm=llm,  # 绑定大语言模型
            actions=[SearchAction()]  # 绑定搜索动作
        )


# 示例：使用搜索代理执行任务
if __name__ == "__main__":
    # 初始化搜索代理
    search_agent = SearchAgent(llm=llm)

    # 创建搜索任务
    task = TaskPackage(instruction="2025年量化交易市场前景")

    # 执行任务
    raw_results = search_agent(task)
    print("原始搜索结果:", raw_results)

调用测试：

没有问题，正常调用，其也进行了思考和回答生成；

5.多Agent实战

现在我们开始构建多Agent系统,这里我们直接开始构建：

① 场景描述：

• 在信息爆炸的时代，用户需要快速获取新闻摘要以节省时间。我们的目标是构建一个多智能体系统，能够从多个新闻源获取最新新闻，并生成简洁的摘要，供用户快速浏览。

② 系统设计

③ 代码实现

import os
from dotenv import load_dotenv
from typing import List, Dict, Any
import requests

from zigent.agents import BaseAgent
from zigent.llm.agent_llms import LLM
from zigent.actions.BaseAction import BaseAction
from zigent.commons import TaskPackage
from duckduckgo_search import DDGS

# 加载环境变量
load_dotenv()

# 从环境变量中读取API配置
api_key = os.getenv('API_KEY')  # 大模型API密钥
base_url = os.getenv('BASE_URL')  # 大模型服务地址
chat_model = os.getenv('MODEL_NAME')  # 使用的模型名称

# 初始化大语言模型（LLM）
llm = LLM(api_key=api_key, base_url=base_url, model_name=chat_model)

# 测试LLM连接
response = llm.run("你是谁？")
print("LLM响应:", response)

# 定义新闻获取动作
class NewsFetchAction(BaseAction):
    def __init__(self):
        super().__init__(
            action_name="NewsFetch",
            action_desc="从DuckDuckGo获取最新新闻链接。",
            params_doc={"query": {"description": "搜索关键词", "type": "string", "required": True}},
        )
        self.ddgs = DDGS()

    def __call__(self, query: str) -> List[Dict[str, Any]]:
        try:
            results = list(self.ddgs.text(query, max_results=5))
            return results
        except Exception as e:
            return f"error: {str(e)}"

class BlogCreationAction(BaseAction):
    def __init__(self):
        super().__init__(
            action_name="BlogCreation",
            action_desc="根据新闻摘要生成博客文章。",
            params_doc={"summaries": {"description": "新闻摘要列表", "type": "list", "required": True}},
        )

    def __call__(self, summary: str) -> str:
        try:
            prompt = f"请根据以下新闻摘要撰写一篇博客文章：\n\n{summary}"
            blog_content = llm.run(prompt)
            return blog_content
        except Exception as e:
            return f"生成博客文章时出错：{str(e)}"


class BlogPublishAction(BaseAction):
    def __init__(self):
        super().__init__(
            action_name="BlogPublish",
            action_desc="将博客文章发布到指定平台。",
            params_doc={"content": {"description": "博客文章内容", "type": "string", "required": True},
                        "platform": {"description": "发布平台", "type": "string", "required": True}},
        )

    def __call__(self, content: str, platform: str) -> str:
        try:
            # 这里以打印为例，实际应用中可以调用相应平台的API进行发布
            print(f"发布到{platform}:\n{content}")
            return f"成功将博客文章发布到{platform}。"
        except Exception as e:
            return f"发布博客文章时出错：{str(e)}"



# 定义新闻获取代理
class NewsFetcherAgent(BaseAgent):
    def __init__(self, llm: LLM):
        super().__init__(
            name="news_fetcher_agent",
            role="从DuckDuckGo获取最新新闻。",
            llm=llm,
            actions=[NewsFetchAction()],
        )

    def fetch_news(self, query: str) -> List[Dict[str, Any]]:
        # Create a task package with the query parameter
        task = TaskPackage(instruction=query)
        # Call the agent with the task package
        return self(task)

## 定义新闻摘要代理
class NewsSummarizerAgent(BaseAgent):
    def __init__(self, llm: LLM):
        super().__init__(
            name="news_summarizer_agent",
            role="对获取的新闻内容进行摘要。",
            llm=llm,
            actions=[BlogCreationAction()],
        )

    def summarize_news(self, news_results: List[Dict[str, Any]]) -> str:
        summaries = []
        for result in news_results:
            if isinstance(result, dict) and 'body' in result:
                news_content = result['body']
                title = result.get('title', '无标题')
                prompt = f"请为以下新闻内容撰写一篇简短的总结：\n\n标题：{title}\n内容：{news_content}"
                summary = self.llm.run(prompt)
                summaries.append(summary)
        
        if not summaries:
            return "未能获取到任何有效的新闻内容"
            
        # 将所有摘要合并成一个字符串，并添加一个总体性的提示
        combined_content = "以下是最新的科技新闻摘要：\n\n" + "\n\n".join(summaries)
        prompt = f"请根据以下新闻摘要，撰写一篇完整的科技新闻综述文章：\n\n{combined_content}"
        
        # 调用BlogCreationAction生成博客文章
        blog_content = self.llm.run(prompt)
        return blog_content

# 定义新闻发布代理
class NewsPublisherAgent(BaseAgent):
    def __init__(self, llm: LLM):
        super().__init__(
            name="news_publisher_agent",
            role="将新闻摘要发布到指定平台。",
            llm=llm,
            actions=[BlogPublishAction()],
        )

    def publish_news(self, content: str, platform: str):
        # 调用BlogPublishAction发布博客文章
        result = self.actions[0](content, platform)
        print(result)


# 示例：使用新闻获取和摘要代理
if __name__ == "__main__":
    # 初始化代理
    news_fetcher = NewsFetcherAgent(llm=llm)
    news_summarizer = NewsSummarizerAgent(llm=llm)
    news_publisher = NewsPublisherAgent(llm=llm)

    # 获取新闻
    query = "最近量化市场的趋势"
    content = news_fetcher.fetch_news(query)

    # 摘要新闻并撰写博客
    summaries = news_summarizer.summarize_news(content)
    print("新闻摘要:", summaries)

    # 发布新闻
    news_publisher.publish_news(summaries, platform="微信公众号")

大家可以根据自己的需求来接入平台接口进行发布，或者使用自动化进行发布；

没有问题！👌👌

四、应用案例

对了，wow-agent中提供了几个有趣的案例,因为作者在过去的文章中已经写过这些部分内容了，这边作者直接给出Demo链接和作者的博客链接：

• 哲学家Agent: 在基于MetaGPT构建LLM多智能体 中提供了苏格拉底式教师学生问答智能体
• 教程编写Agent：在基于MetaGPT构建单智能体提供了技术文档编写智能体
• 出题Agent：在LLM微调(数据增强与模型自动打分)-以高考选择题生成模型为例提供了高考题目生成智能体

🎉Demo中是今天Zigent框架实现的代码，我的博客中可能使用了其他框架，但是都提供了代码！🙂🙂👌

OK，今天就学到这里！👌👌🎉

文章参考

• DeepSeek官方文档
• wow-agent

项目地址

• AgentLite
• 拓展阅读
• 专栏文章

如果觉得我的文章对您有帮助，三连+关注便是对我创作的最大鼓励！或者一个star🌟也可以😂.