GraphRAG + AutoGen + Ollama + Chainlit = 本地和免费的多代理 RAG 超级机器人

集成和关键组件的图形摘要

Rag （RAG） 是一种强大的工具，它使大型语言模型 （LLM） 能够访问真实世界的数据以获得更明智的响应。这是通过将模型与矢量数据库集成以实现实时学习和适应来实现的。此功能使 RAG 成为聊天机器人和虚拟助手等应用的首选，在这些应用中，对实时准确和明智的响应的需求很高。其中一种高级变体，称为图检索增强生成（GraphRAG），将基于图的知识检索与LLMs的优点相结合，进一步增强了自然语言处理的能力。与依赖于向量相似性搜索的传统 RAG 方法不同，GraphRAG 从原始文本构建结构化知识图谱，捕获实体、关系和关键声明。这可以增强 LLM 理解和综合复杂数据集及其关系的能力，从而产生更准确和基于上下文的响应。

AutoGen 是 Microsoft 的一款工具，它通过自动化和优化曾经复杂且需要大量手动工作的工作流程，简化了基于多代理 LLM 的复杂应用程序的开发。将 AutoGen 想象成一个平台，您可以在其中与多个 GPT 交互，而不仅仅是一个。每个 GPT 都充当单独的“代理”，在综合操作中发挥着独特的作用。将 GraphRAG 的检索优势与 AutoGen AI 代理的对话和面向任务的功能相结合，可以产生强大的 AI 助手，能够有效地处理详细的查询、生成和执行代码、创建多页科学报告以及进行数据分析。此外，离线本地 LLM，例如来自 Ollama 或 LM Studio 的 LLM，可确保经济高效且安全的数据处理。本地 LLM 消除了与在线 LLM 相关的高成本和隐私风险，将敏感数据保留在组织内并降低运营费用。

本文将指导您使用 GraphRAG 检索系统构建多代理 AI 应用程序，该系统完全在您的本地机器上运行，并且免费提供。以下是此应用程序的关键组件：

1. GraphRAG的知识搜索方法通过函数调用与AutoGen代理集成。

2. GraphRAG（本地和全局搜索）配置为支持来自Ollama的本地模型进行推理和嵌入。

3. AutoGen 已扩展为支持通过 Lite-LLM 代理服务器从 Ollama 进行非 OpenAI LLM 的函数调用。

4. Chainlit 用户界面，用于处理连续对话、多线程和用户输入设置。

凭借我的材料科学和计算建模背景，我想通过从 ABAQUS 文档、FEA 工程软件以及碳纤维和聚合物的一些技术数据表中构建知识图谱来测试此应用程序。考虑到该数据集的复杂性，使用本地 LLM 的整体准确性可能会更好。未来的文章将探讨从使用不同模型进行嵌入和推理的基准研究中学到的知识。尽管如此，我还是渴望从该领域的科学期刊和数据中构建更复杂的知识图谱，测试高级工程代码生成任务，并利用对话助手在我的专业知识范围内集思广益。该应用程序看起来像这样。

带有示例查询的主应用程序 UI。最后两个具有相同的查询，但第一个是全局搜索，而第二个是本地搜索。

小部件设置，用于在本地和全局搜索之间切换，设置社区级别和生成长度。

开发是在 Linux 环境中使用适用于 Linux 的 Windows 子系统 （WSL） 和 Visual Studio Code 在配备 i9 第 13 代处理器、64 GB RAM 和 24 GB Nvidia RTX 4090 的 Windows 11 PC 上完成的。为了获得开发和测试此应用的最佳体验，建议使用 Linux 发行版或 WSL。我尚未在本机 Windows 环境中对此进行测试。有关安装 WSL 以及设置 Python 和 Conda 环境的指南，请参阅本文（此处）。本文末尾提供了其他参考资料和相关信息。

这是源代码存储库的链接。现在，让我们开始吧！！

安装模型依赖项和克隆存储库。

从 Ollama 安装语言模型以进行推理和嵌入

\# Mistral for GraphRAG Inference  
ollama pull mistral  
  
\# Nomic-Embed-Text for GraphRAG Embedding  
ollama pull nomic-embed-text  
  
\# LLama3 for Autogen Inference  
ollama pull llama3  
  
\# Host Ollama on a local server: http://localhost:11434  
ollama serve

创建 conda 环境并安装这些依赖项

\# Create and activate a conda environment  
conda create -n RAG\_agents python=3.12  
conda activate RAG\_agents  
  
\# Lite-LLM proxy server for Ollama  
pip install 'litellm\[proxy\]'  
  
\# Install Ollama  
pip install ollama  
  
\# Microsoft AutoGen  
pip install pyautogen "pyautogen\[retrievechat\]"   
  
\# Microsoft GraphRAG  
pip install graphrag  
  
\# Text-Token Encoder-Decoder  
pip install tiktoken  
  
\# Chainlit Python application  
pip install chainlit  
  
\# Clone my Git-hub repository  
git clone https://github.com/karthik-codex/autogen\_graphRAG.git  
  
\# (BONUS) To Convert PDF files to Markdown for GraphRAG   
pip install marker-pdf  
  
\# (BONUS) Only if you installed Marker-pdf since it removes GPU CUDA support by default  
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

您将在我的 GitHub 存储库中找到以下文件。

1. /requirements.txt— 包含上述所有软件包的列表

2. /utils/settings.yaml— 包含使用 Ollama 的 Mistral 7B 和 Nomic-Text-Embedding 进行 GraphRAG 离线嵌入和索引的 LLM 配置。 您将使用此文件来替换首次在工作目录中初始化 GraphRAG 时创建的文件。

3. /utils/chainlit_agents.py— 包含包括 AutoGen 的助手和用户代理代理的类定义。这允许跟踪多个代理，并在UI中显示其消息。（感谢 Chainlit 团队构建了 模板_）。_

4. /utils/embedding.py- 包含修改后的嵌入函数，用于使用 Ollama 进行本地搜索查询的 GraphRAG 嵌入。您将使用此文件来替换 GraphRAG 包中的文件（更多信息见下文）

5. utils/openai_embeddings_llm.py—C_使用 Ollama 保留了修改后的嵌入函数，用于 GraphRAG 索引和嵌入。您将使用此文件来替换 GraphRAG 包中的文件（更多信息见下文）。_

6. /appUI.py- 包含主要的异步函数，用于设置代理、定义 GraphRAG 搜索函数、跟踪和处理消息，并在 Chainlit UI 中显示它们。

7. /utils/pdf_to_markdown.py— 包含将 PDF 文件转换为 Markdown 文件以进行 GraphRAG 摄取的函数的奖励文件。

创建 GraphRAG 知识库。

在存储库的根文件夹中初始化 GraphRAG

#make a new folder "input" to place your input files for GraphRAG (.txt or .md)  
mkdir -p ./input  
  
\# Initialize GraphRAG to create the required files and folders in the root dir  
python -m graphrag.index --init  --root .  
  
\# Move the settings.yaml file to replace the one created by GraphRAG --init  
mv ./utils/settings.yaml ./

配置 GraphRAG 设置以支持 Ollama 的本地模型

下面是一个片段，展示了用于创建索引和嵌入的 LLM 的配置。GraphRAG 需要 32k 上下文长度进行索引，因此 Mistral 成为所选模型。对于嵌入，选择了 Nomic-embed-text，尽管您可以尝试使用 Ollama 中的其他嵌入。无需设置 ，因为不需要访问这些本地模型的端点。settings.yaml``${GRAPHRAG_API_KEY}

encoding\_model: cl100k\_base  
skip\_workflows: \[\]  
llm:  
  api\_key: ${GRAPHRAG\_API\_KEY}  
  type: openai\_chat \# or azure\_openai\_chat  
  model: mistral  
  model\_supports\_json: true  
  api\_base: http://localhost:11434/v1   
.  
.  
.  
embeddings:  
  async\_mode: threaded \# or asyncio  
  llm:  
    api\_key: ${GRAPHRAG\_API\_KEY}  
    type: openai\_embedding \# or azure\_openai\_embedding  
    model: nomic\_embed\_text  
    api\_base: http://localhost:11434/api   
.  
.  
.  
input:  #Change input file pattern to.md, or .txt  
  type: file \# or blob  
  file\_type: text \# or csv  
  base\_dir: "input"  
  file\_encoding: utf-8  
  file\_pattern: ".\*\\\\.md$"

您可以在根目录的“input”文件夹中指定包含输入文件的文件夹。文本和 Markdown 文件都可以使用。您可以使用 将 PDF 转换为 markdown 文件，然后将其放置在“输入”文件夹中。处理多种文件格式尚未弄清楚，但这是一个可以解决的问题。/utils/pdf_to_markdown.py

在运行 GraphRAG 进行索引、创建嵌入和执行本地查询之前，您必须修改 Python 文件并位于 GraphRAG 包中。如果不进行此修改，GraphRAG 在创建嵌入时将抛出错误，因为它无法将“nomic-embed-text”识别为 Ollama 的有效嵌入模型。在我的设置中，这些文件位于 和openai_embeddings_llm.py embedding.py``/home/karthik/miniconda3/envs/RAG_agents/lib/python3.12/site-packages/graphrag/llm/openai/openai_embeddings_llm.py``/home/karthik/miniconda3/envs/RAG_agents/lib/python3.12/site-packages/graphrag/query/llm/oai/embedding.py

您可以使用命令找到这些文件。sudo find / -name openai_embeddings_llm.py

创建嵌入和知识图谱。

最后，我们创建嵌入并使用全局或局部搜索方法测试知识图谱。完成嵌入过程后，您可以在 GraphRAG 工作目录的“output”文件夹中找到输出工件（.parquet 文件）和报告（.json 和 .logs），该文件夹是本例中的根文件夹。

\# Create knowledge graph - this takes some time  
python -m graphrag.index --root .  
  
\# Test GraphRAG  
python -m graphrag.query --root . --method global "<insert your query>"

启动 Lite-LLM 服务器并从终端运行应用程序

以下是在运行应用程序之前初始化服务器的命令。我选择了Llama3：8b来测试这个应用程序。如果硬件允许，可以使用更大的模型。有关Lite-LLM的更多信息，请访问此链接。现在，您已准备好从另一个终端运行应用程序。请确保您处于正确的 conda 环境中。

\# start server from terminal  
litellm --model ollama\_chat/llama3  
  
\# run app from another terminal  
chainlit run appUI.py

细分：appUI.py 的核心组成部分

导入 python 库

import autogen  
from rich import print  
import chainlit as cl  
from typing\_extensions import Annotated  
from chainlit.input\_widget import (  
   Select, Slider, Switch)  
from autogen import AssistantAgent, UserProxyAgent  
from utils.chainlit\_agents import ChainlitUserProxyAgent, ChainlitAssistantAgent  
from graphrag.query.cli import run\_global\_search, run\_local\_search

您会注意到正在从 chainlit_agents 导入两个类。这些用于 AutoGen 代理的包装类使 Chainlit 能够跟踪他们的对话并处理终止或其他用户输入。您可以在此处阅读有关此内容的更多信息。

配置 AutoGen 代理

AutoGen 代理通过 Lite-LLM 代理服务器利用 Ollama 的模型。这是必要的，因为 AutoGen 不支持通过非 OpenAI 推理模型调用函数。代理服务器允许使用 Ollama 模型进行函数调用和代码执行。

\# LLama3 LLM from Lite-LLM Server for Agents #  
llm\_config\_autogen = {  
    "seed": 40,  \# change the seed for different trials  
    "temperature": 0,  
    "config\_list": \[{"model": "litellm",   
                     "base\_url": "http://0.0.0.0:4000/",   
                     'api\_key': 'ollama'},  
    \],  
    "timeout": 60000,  
}

在聊天开始时实例化代理并输入用户设置

我创建了三个 Chainlit 小部件（开关、选择和滑块）作为用户设置，以选择 GraphRAG 搜索类型、社区级别和内容生成类型。启用后，开关小部件将使用 GraphRAG 本地搜索方法进行查询。内容生成的选择选项包括“优先级列表”、“单个段落”、“多个段落”和“多页报告”。滑块小组件使用选项 0、1 和 2 选择社区生成级别。您可以在此处阅读有关 GraphRAG 社区的更多信息。

@cl.on\_chat\_start  
async def on\_chat\_start():  
  try:  
    settings = await cl.ChatSettings(  
            \[        
                Switch(id\="Search\_type", label="(GraphRAG) Local Search", initial=True),         
                Select(  
                    id\="Gen\_type",  
                    label="(GraphRAG) Content Type",  
                    values=\["prioritized list", "single paragraph", "multiple paragraphs", "multiple-page report"\],  
                    initial\_index=1,  
                ),            
                Slider(  
                    id\="Community",  
                    label="(GraphRAG) Community Level",  
                    initial=0,  
                    min\=0,  
                    max\=2,  
                    step=1,  
                ),  
  
            \]  
        ).send()  
  
    response\_type = settings\["Gen\_type"\]  
    community = settings\["Community"\]  
    local\_search = settings\["Search\_type"\]  
      
    cl.user\_session.set("Gen\_type", response\_type)  
    cl.user\_session.set("Community", community)  
    cl.user\_session.set("Search\_type", local\_search)  
  
    retriever   = AssistantAgent(  
       name="Retriever",   
       llm\_config=llm\_config\_autogen,   
       system\_message="""Only execute the function query\_graphRAG to look for context.   
                    Output 'TERMINATE' when an answer has been provided.""",  
       max\_consecutive\_auto\_reply=1,  
       human\_input\_mode="NEVER",   
       description="Retriever Agent"  
    )  
  
    user\_proxy = ChainlitUserProxyAgent(  
        name="User\_Proxy",  
        human\_input\_mode="ALWAYS",  
        llm\_config=llm\_config\_autogen,  
        is\_termination\_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),  
        code\_execution\_config=False,  
        system\_message='''A human admin. Interact with the retriever to provide any context''',  
        description="User Proxy Agent"  
    )  
      
    print("Set agents.")  
  
    cl.user\_session.set("Query Agent", user\_proxy)  
    cl.user\_session.set("Retriever", retriever)  
  
    msg = cl.Message(content=f"""Hello! What task would you like to get done today?        
                     """,   
                     author="User\_Proxy")  
    await msg.send()  
  
    print("Message sent.")  
      
  except Exception as e:  
    print("Error: ", e)  
    pass

我选择不将 Chainlit 包装类用于检索器助理代理。这使我能够禁用对检索器输出的跟踪，并直接从 GraphRAG 函数捕获响应。原因是当响应通过检索器时，文本会丢失其格式，包括空格和段落缩进。在生成包含主标题和副标题的多页报告时，这个问题尤为明显。我可以通过绕过 Chainlit 包装器并直接从 GraphRAG 函数检索输出来保留原始格式。您将在下面看到我是如何实现这一目标的。

更新输入设置中的更改

此函数会检测设置中对选择、切换和滑块小部件所做的任何更改，以便它可以在后续查询中反映这些更改。

@cl.on\_settings\_update  
async def setup\_agent(settings):  
    response\_type = settings\["Gen\_type"\]  
    community = settings\["Community"\]  
    local\_search = settings\["Search\_type"\]  
    cl.user\_session.set("Gen\_type", response\_type)  
    cl.user\_session.set("Community", community)  
    cl.user\_session.set("Search\_type", local\_search)  
    print("on\_settings\_update", settings)

使用来自代理和用户的传入消息更新 UI。

这是应用程序的核心部分，它创建一个带有两个代理的群聊，定义一个函数“state_transition”来管理对话序列，并提供异步 RAG 查询功能。

您会注意到根据 bool 参数传递到本地和全局搜索 GraphRAG 查询函数中的参数。设置为 — 如果您在不同的目录中初始化了 GraphRAG，请注意这一点。INPUT_DIR ,ROOT_DIR,``RESPONSE_TYPE,``COMMUNTIY``LOCAL_SEARCH``ROOT_DIR,``’.’

异步函数“query_graphRAG”调用 GraphRAG 全局或本地搜索方法。您会注意到函数内部的行，该行直接检索 RAG 查询的输出并保留检索内容的文本格式。await cl.Message(content=result.response).send()``async def query_graphRAG

@cl.on\_message  
async def run\_conversation(message: cl.Message):  
    print("Running conversation")  
    CONTEXT = message.content  
  
    MAX\_ITER = 10  
    INPUT\_DIR = None  
    ROOT\_DIR = '.'  
    RESPONSE\_TYPE = cl.user\_session.get("Gen\_type")  
    COMMUNITY = cl.user\_session.get("Community")  
    LOCAL\_SEARCH = cl.user\_session.get("Search\_type")  
  
    print("Setting groupchat")  
  
    retriever   = cl.user\_session.get("Retriever")  
    user\_proxy  = cl.user\_session.get("Query Agent")  
  
    def state\_transition(last\_speaker, groupchat):  
        messages = groupchat.messages  
        if last\_speaker is user\_proxy:  
            return retriever  
        if last\_speaker is retriever:  
            if messages\[-1\]\["content"\].lower() not in \['math\_expert','physics\_expert'\]:  
                return user\_proxy  
            else:  
                if messages\[-1\]\["content"\].lower() == 'math\_expert':  
                    return user\_proxy  
                else:  
                    return user\_proxy  
        else:  
            pass  
            return None  
  
    async def query\_graphRAG(          question: Annotated\[str, 'Query string containing information that you want from RAG search'\]                          ) -> str:  
        if LOCAL\_SEARCH:  
            result = run\_local\_search(INPUT\_DIR, ROOT\_DIR, COMMUNITY ,RESPONSE\_TYPE, question)  
        else:  
            result = run\_global\_search(INPUT\_DIR, ROOT\_DIR, COMMUNITY ,RESPONSE\_TYPE, question)  
        await cl.Message(content=result).send()  
        return result  
  
    for caller in \[retriever\]:  
        d\_retrieve\_content = caller.register\_for\_llm(  
            description="retrieve content for code generation and question answering.", api\_style="function"  
        )(query\_graphRAG)  
  
    for agents in \[user\_proxy, retriever\]:  
        agents.register\_for\_execution()(d\_retrieve\_content)  
  
    groupchat = autogen.GroupChat(  
        agents=\[user\_proxy, retriever\],  
        messages=\[\],  
        max\_round=MAX\_ITER,  
        speaker\_selection\_method=state\_transition,  
        allow\_repeat\_speaker=True,  
    )  
    manager = autogen.GroupChatManager(groupchat=groupchat,  
                                       llm\_config=llm\_config\_autogen,   
                                       is\_termination\_msg=lambda x: x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE"),  
                                       code\_execution\_config=False,  
                                       )      
  
\# -------------------- Conversation Logic. Edit to change your first message based on the Task you want to get done. ----------------------------- #   
    if len(groupchat.messages) == 0:   
      await cl.make\_async(user\_proxy.initiate\_chat)( manager, message=CONTEXT, )  
    elif len(groupchat.messages) < MAX\_ITER:  
      await cl.make\_async(user\_proxy.send)( manager, message=CONTEXT, )  
    elif len(groupchat.messages) == MAX\_ITER:    
      await cl.make\_async(user\_proxy.send)( manager, message="exit", )

对于此应用程序，我们只需要两个代理。您可以添加/修改座席并配置“state_transition”功能，以编排对话中的发言者选择，以实现更复杂的工作流程。

最后的思考

这是我第一次涉足 AI 代理、LLM 和 RAG，在过去的几周里，我绕过了许多基础知识，直接投入到创建这个实现中。虽然这种实现并不完美，但它是开发更复杂应用程序的绝佳模板。它为集成多个功能和编码代理奠定了坚实的基础，应该使您能够构建复杂的工作流程、自定义代理交互并根据需要增强功能。

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】