使用 Llama-Agents、Qdrant 和 Kafka 进行高级实时 RAG

在当今数据驱动的世界中，实时处理和检索信息的能力至关重要。本文深入探讨了使用 Llama-Agents、Qdrant 和 Kafka 的 高级实时检索增强生成（RAG）。通过整合这些强大的工具，我们创建了一个智能系统，能够高效管理数据的摄取、处理和检索。了解这种架构如何动态处理用户查询、平衡工作负载，并确保无缝访问有价值的数据，从而改变组织管理信息工作流的方式。

架构：

该过程始于一个 大型 JSON 对象，作为初始数据源。这个 JSON 对象被摄取到 MongoDB 中，MongoDB 是一个以灵活性和可扩展性著称的 NoSQL 数据库。MongoDB 便于高效存储和检索大型 JSON 对象，为进一步处理做好准备。

从 MongoDB 摄取的数据随后通过 Confluent 的 Kafka 源连接器 转移。这些连接器使数据能够流入 Kafka，确保数据的顺畅和高效流动。

一旦数据进入 Kafka，就会发布到 Kafka 消息队列。Kafka 在该架构中充当中央枢纽，管理和路由系统各组件之间的数据流。集成由 Qdrant 的 Kafka 接收连接器 促进，确保数据的无缝索引和检索。

来自用户的数据被交给 信息检索代理。该代理负责执行 语义搜索 操作。它使用汇总的数据并与 Qdrant 的实时数据 进行交互，Qdrant 是一个优化用于语义搜索的向量数据库。

下一个组件是 汇总代理，它处理来自 信息检索代理 的数据。该代理利用大型语言模型 Mistral-7b 来汇总传入的信息。

数据摄取：

下面的代码使用指定的参数创建一个 Qdrant 集合。然后，它从一个 ‘data.json’ 文件加载数据。在使用 MongoClient 建立与 MongoDB 的连接后，它选择 ‘startups’ 数据库及其中的 ‘docs’ 集合。

对于加载的 JSON 数据中的每个对象，脚本提取名称、图像、替代文本、描述、链接和城市等属性。它使用指定的嵌入模型为描述创建文本嵌入，构建一个包含集合名称、唯一 ID、嵌入向量和包含提取属性的有效载荷的文档。然后将该文档插入到 MongoDB 集合中。

from pymongo import MongoClient
from utils.app_utils import create_qdrant_collection
from fastembed import TextEmbedding
import json

collection_name: str = 'startups'
embed_model_name: str = 'snowflake/snowflake-arctic-embed-s'

# Ste 0: create qdrant_collection
create_qdrant_collection(collection_name=collection_name, embed_model=embed_model_name)

with open(file='data.json', mode='r') as file:
    data = json.load(file)

# Step 1: Connect to MongoDB
client = MongoClient('mongodb://127.0.0.1:27017/?replicaSet=rs0&directConnection=true')

# Step 2: Select Database
db = client['startups']

# Step 3: Select Collection
collection = db['docs']

for index, obj in enumerate(data):
    # Extract properties
    name: str = obj.get('name')
    images: str = obj.get('images')
    alt: str = obj.get('alt')
    description: str = obj.get('description')
    link: str = obj.get('link')
    city: str = obj.get('city')

    # Step 4: Create a Document to Insert
    embedding_model = TextEmbedding(model_name=embed_model_name)
    vector = next(embedding_model.embed(documents=description)).tolist()
    document = {
        "collection_name": collection_name,
        "id": index+1,
        "vector": vector,
        "payload": {
            "name": name,
            "city": city,
            "description": description,
            "images": images,
            "url": link
        }
    }

    # Step 5: Insert the Document into the Collection
    result = collection.insert_one(document)

    # Step 6: Print the Inserted Document's ID
    print("Inserted document ID:", result.inserted_id)

一旦数据被摄取到 Mongodb 中，我们的 CDC 就会启动，最终数据会出现在 Qdrant 中。有关 CDC 设置的详细说明，请 查看本文。

RAG 在实时数据上的应用：

以下代码定义了一个类 HybridQdrantOperations，用于管理在 Qdrant 服务器上的混合搜索操作。它初始化一个密集和稀疏嵌入模型，连接到本地 Qdrant 服务器，并加载一个 JSON 负载。hybrid_search 方法在执行时进行计时，使用 Qdrant 客户端执行搜索，返回给定查询文本的前几个相似结果的元数据。

import json
from qdrant_client import QdrantClient, models
from utils.decorator_utils import execution_time_decorator


class HybridQdrantOperations:
    def __init__(self):
        self.payload_path = "../data.json"
        self.collection_name = "startups"
        self.DENSE_MODEL_NAME = "snowflake/snowflake-arctic-embed-s"
        self.SPARSE_MODEL_NAME = "prithivida/Splade_PP_en_v1"
        # collect to our Qdrant Server
        self.client = QdrantClient(host="localhost", port=6333, api_key="th3s3cr3tk3y")
        self.client.set_model(self.DENSE_MODEL_NAME)
        # comment this line to use dense vectors only
        self.client.set_sparse_model(self.SPARSE_MODEL_NAME)
        self.metadata = []
        self.documents = []

    @execution_time_decorator
    def hybrid_search(self, text: str, top_k: int = 5):
        # self.client.query will have filters also if you want to do query on filter data.
        search_result = self.client.query(
            collection_name=self.collection_name,
            query_text=text,
            limit=top_k,  # 5 the closest results
        )
        # `search_result` contains found vector ids with similarity scores
        # along with the stored payload

        # Select and return metadata
        metadata = [hit.metadata for hit in search_result]
        return metadata

以下代码使用 llama-agents 和 kafka 设置了一个基于代理的系统，以管理和检索关于初创公司的信息。它首先初始化一个 HybridQdrantOperations 实例以进行混合搜索，并配置日志记录和 Kafka 连接详细信息。使用特定参数创建一个 Ollama 模型的实例，并使用 OllamaEmbedding 设置嵌入模型。

定义了一个函数 get_startup_info 来通过 Qdrant 执行混合搜索并将结果作为 JSON 返回。该函数使用 FunctionTool 包装成一个工具，并使用 ReActAgent 类创建一个代理 startup_tool_agent，配备该工具。另一个代理 summarization_agent 也被实例化，但没有任何工具。

该系统使用 KafkaMessageQueue 进行消息处理，连接到指定的 Kafka URL。初始化一个 ControlPlaneServer，将消息队列和 AgentOrchestrator 结合在一起，将控制平面的服务器端口设置为 8001。创建了两个 AgentService 实例：startup_service 用于检索初创公司信息，summarization_service 用于总结信息，每个实例都与各自的 代理 和 Kafka 消息队列 关联，并分配唯一的服务端口（8002 和 8003）。该设置通过代理交互促进了初创公司信息的无缝检索和总结。

from llama_index.core import Settings
from llama_agents import (
    AgentService,
    AgentOrchestrator,
    ControlPlaneServer
)
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_agents.message_queues.apache_kafka import KafkaMessageQueue
from llama_index.core.agent import ReActAgent
from llama_index.core.tools import FunctionTool
from llama_index.llms.ollama import Ollama
from retrievers.qdrant_ops import HybridQdrantOperations
import json

qdrant_ops = HybridQdrantOperations()
is_logging_enabled = True
# better managed from env
KAFKA_CONNECTION_URL = "localhost:9092"
llm = Ollama(base_url='http://localhost:11434', model='mistral:latest', temperature=0.8, request_timeout=300,
             system_prompt="You are an agent who consider the context passed "
                           "in, to answer any questions dont consider your prior "
                           "knowledge to answer and if you dont find the answer "
                           "please respond that you dont know.")
Settings.embed_model = OllamaEmbedding(base_url='http://localhost:11434', model_name='snowflake-arctic-embed:33m')


# create an agent
def get_startup_info(query: str) -> str:
    """Returns the information about startups."""
    if is_logging_enabled:
        print(f"Query from agent: {query}")
    resp = qdrant_ops.hybrid_search(text=query, top_k=5)
    if is_logging_enabled:
        print(f"Response from search: {resp}")
    return json.dumps(resp)


startup_info_tool = FunctionTool.from_defaults(fn=get_startup_info)
startup_tool_agent = ReActAgent.from_tools(tools=[startup_info_tool], llm=llm)
summarization_agent = ReActAgent.from_tools(tools=[], llm=llm)

message_queue = KafkaMessageQueue(url=KAFKA_CONNECTION_URL)

control_plane = ControlPlaneServer(
    message_queue=message_queue,
    orchestrator=AgentOrchestrator(llm=llm),
    port=8001,
)
startup_service = AgentService(
    agent=startup_tool_agent,
    message_queue=message_queue,
    description="Useful for getting the information about startups.",
    service_name="info_extract_agent",
    port=8002,
)
summarization_service = AgentService(
    agent=summarization_agent,
    message_queue=message_queue,
    description="Useful for consolidating or summarizing the information.",
    service_name="info_summarization_agent",
    port=8003,
)

以下代码设置了一个 LocalLauncher 来管理和执行使用先前定义的 startup_service、summarization_service、control_plane 和 message_queue 的代理服务。然后它进入一个无限循环，提示用户输入查询。如果用户输入 ‘bye’ 或 ‘exit’，循环将中断，程序结束。对于其他输入，启动程序使用 launch_single 方法执行查询并打印结果。该设置使得可以通过代理系统进行信息检索和总结的交互查询。

from llama_agents import LocalLauncher
from agent_with_rag_tool import startup_service, summarization_service, control_plane, message_queue

# launch it
launcher = LocalLauncher(
    [startup_service, summarization_service],
    control_plane,
    message_queue,
)

while True:
    input_query = input("Query (type 'bye' or 'exit' to quit the program ):")
    if input_query.lower() == 'bye' or input_query.lower() == 'exit':
        break
    result = launcher.launch_single(initial_task=input_query)
    print(f"Result: {result}")

一旦一切运行正常，下面应该是输出结果。

背景中发生了什么？

系统使用 llama-agents 框架通过 Kafka 平台管理查询，确保高效的主题创建、平衡和删除。当用户提交查询时，框架动态创建所需的 Kafka 主题并为这些主题注册消费者。然后启动代理以处理查询。控制平面协调工作流程，发布消息以启动任务并处理其完成。在查询处理并提供响应后，框架停止消费者并删除不再需要的主题，以确保高效的资源管理和系统性能。

未来（高度可扩展的概念）

上述架构是一个Agentic System，不同团队可以与专用代理进行交互，从多个数据源中检索相关信息，这些数据源包括Salesforce、Jira和AWS CloudWatch。这些源分别提供客户数据、项目管理信息和应用程序日志。以下是架构的详细分解：

数据源：

• Salesforce：管理与客户和销售相关的数据，包括潜在客户和机会。
• Jira：处理项目管理任务和问题。
• AWS CloudWatch：收集和监控应用程序日志。

源连接器：这些数据源的数据通过Confluent的Kafka源连接器被导入系统，实现数据流向Kafka的无缝传输。

Kafka消息队列：Kafka作为中央枢纽，管理和路由数据流向系统内的各个代理和组件。

代理：

• 信息检索代理：从导入的流中检索特定数据。
• 汇总代理：处理并汇总检索到的数据，以便于理解。

Qdrant：使用Qdrant Kafka接收连接器存储和索引数据，实现高效的语义搜索能力。

控制平面：

• 协调者：管理工作流和数据处理顺序。
• 服务元数据：存储与系统内服务和操作相关的元数据。

系统的五种用途

1. 客户数据管理：通过与Salesforce的集成，销售团队可以向信息检索代理请求客户和销售相关的数据，如潜在客户和机会，确保他们拥有最新的信息。
2. 项目管理：通过集成Jira，管理者可以查询摘要代理以获取项目进展的简要更新，管理问题，并检索详细的项目信息，有助于维护项目时间表和提高生产力。
3. 日志监控：工程团队可以查询由AWS CloudWatch收集的应用程序日志。该系统为他们提供洞察和详细日志，以有效跟踪性能问题和故障排除。

结论：

在对一个强大的数据处理和检索系统的探索中，我们深入研究了如何通过将 llama-agents 框架与 Kafka 和 Qdrant 集成，有效管理用户查询和数据操作。通过利用 Salesforce、Jira 和 AWS CloudWatch 等组件，该系统确保了有价值数据的无缝摄取、处理和检索。这个智能系统动态处理 Kafka 主题，使各个团队能够与提供精确、符合其需求的信息的专用代理进行互动。资源的高效管理突显了系统在平衡工作负载和维持性能方面的能力。最终，这种架构展示了一种管理复杂数据工作流程的复杂方法，为希望增强其数据处理生成 AI 能力的组织提供了宝贵的蓝图。

​

如何学习大模型

现在社会上大模型越来越普及了，已经有很多人都想往这里面扎，但是却找不到适合的方法去学习。

作为一名资深码农，初入大模型时也吃了很多亏，踩了无数坑。现在我想把我的经验和知识分享给你们，帮助你们学习AI大模型，能够解决你们学习中的困难。

下面这些都是我当初辛苦整理和花钱购买的资料，现在我已将重要的AI大模型资料包括市面上AI大模型各大白皮书、AGI大模型系统学习路线、AI大模型视频教程、实战学习，等录播视频免费分享出来，需要的小伙伴可以扫取。

一、AGI大模型系统学习路线

很多人学习大模型的时候没有方向，东学一点西学一点，像只无头苍蝇乱撞，我下面分享的这个学习路线希望能够帮助到你们学习AI大模型。

二、AI大模型视频教程

三、AI大模型各大学习书籍

四、AI大模型各大场景实战案例

五、结束语

学习AI大模型是当前科技发展的趋势，它不仅能够为我们提供更多的机会和挑战，还能够让我们更好地理解和应用人工智能技术。通过学习AI大模型，我们可以深入了解深度学习、神经网络等核心概念，并将其应用于自然语言处理、计算机视觉、语音识别等领域。同时，掌握AI大模型还能够为我们的职业发展增添竞争力，成为未来技术领域的领导者。

再者，学习AI大模型也能为我们自己创造更多的价值，提供更多的岗位以及副业创收，让自己的生活更上一层楼。

因此，学习AI大模型是一项有前景且值得投入的时间和精力的重要选择。