如何使用 CrewAI 和 Qdrant 构建智能代理式 RAG

from typing import Optional
from crewai.memory.storage.rag_storage import RAGStorage

class QdrantStorage(RAGStorage):
    """
    Extends Storage to handle embeddings for memory entries 
    using Qdrant.
    """

    ...

    def search(self,
        query: str,
        limit: int = 3,
        filter: Optional[dict] = None,
        score_threshold: float = 0,
    ) -> list[dict]:
        ...

    def reset(self) -> None:
        ...

from crewai import Crew, Process
from crewai.memory import EntityMemory, ShortTermMemory
from email_assistant.storage import QdrantStorage

qdrant_location= "https://:6333"
qdrant_api_key = "your-secret-api-key"
embedder_config = {...}

crew = Crew(
    agents=[...],
    tasks=[...],  # Automatically created by the @task decorator
    process=Process.sequential,
    memory=True,
    entity_memory=EntityMemory(
        storage=QdrantStorage(
            type="entity-memory",
            embedder_config=embedder_config,
            qdrant_location=qdrant_location,
            qdrant_api_key=qdrant_api_key,
        ),
    ),
    short_term_memory=ShortTermMemory(
        storage=QdrantStorage(
            type="short-term-memory",
            embedder_config=embedder_config,
            qdrant_location=qdrant_location,
            qdrant_api_key=qdrant_api_key,
        ),
    ),
    embedder=embedder_config,
    verbose=True,
)

chunks_extractor:
  role: >
    Semantic chunks extractor
  goal: >
    Parse Markdown to extract digestible pieces of information which are
    semantically meaningful and can be easily understood by a human.
  backstory: >
    You are a search expert building a search engine for Markdown files.
    Once you receive a Markdown file, you divide it into meaningful semantic
    chunks, so each chunk is about a certain topic or concept. You're known 
    for your ability to extract relevant information from large documents and 
    present it in a structured and easy-to-understand format, that increases
    the searchability of the content and results quality.

contextualizer:
  role: >
    Bringing context to the extracted chunks
  goal: >
    Add context to the extracted chunks to make them more meaningful and
    understandable. This context should help the reader understand the
    significance of the information and how it relates to the broader topic.
  backstory: >
    You are a knowledge curator who specializes in making information more
    accessible and understandable. You take the extracted chunks and provide
    additional context to make them more meaningful by bringing in relevant
    information about the whole document or the topic at hand.

extract_chunks:
  description: >
    Review the document you got and extract the chunks from it. Each 
    chunk should be a separate piece of information that can be easily understood 
    by a human and is semantically meaningful. If there are two or more chunks that 
    are closely related, but not put next to each other, you can merge them into 
    a single chunk. It is important to cover all the important information in the
    document and make sure that the chunks are logically structured and coherent.
    
    <document>{document}</document>
  expected_output: >
    A list of semantic chunks with succinct context of information extracted from 
    the document.
  agent: chunks_extractor

contextualize_chunks:
  description: >
    You have the chunks we want to situate within the whole document.
    Please give a short succinct context to situate this chunk within the overall 
    document for the purposes of improving search retrieval of the chunk. Answer 
    only with the succinct context and nothing else.
  expected_output: >
    A short succinct context to situate the chunk within the overall document, along
    with the chunk itself.
  agent: contextualizer

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from email_assistant import models

...

@CrewBase
class KnowledgeOrganizingCrew(BaseCrew):
    """
    A crew responsible for processing raw text data and converting it into structured knowledge.
    """

    agents_config = "config/knowledge/agents.yaml"
    tasks_config = "config/knowledge/tasks.yaml"

    @agent
    def chunks_extractor(self) -> Agent:
        return Agent(
            config=self.agents_config["chunks_extractor"],
            verbose=True,
            llm="anthropic/claude-3-5-sonnet-20241022",
        )

    ...

    @task
    def contextualize_chunks(self) -> Task:
        # The task description is borrowed from the Anthropic Contextual Retrieval
        # See: https://www.anthropic.com/news/contextual-retrieval/
        return Task(
            config=self.tasks_config["contextualize_chunks"],
            output_pydantic=models.ContextualizedChunks,
        )

    ...

    @crew
    def crew(self) -> Crew:
        """Creates the KnowledgeOrganizingCrew crew"""
        return Crew(
            agents=self.agents,  # Automatically created by the @agent decorator
            tasks=self.tasks,  # Automatically created by the @task decorator
            process=Process.sequential,
            memory=True,
            entity_memory=self.entity_memory(),
            short_term_memory=self.short_term_memory(),
            embedder=self.embedder_config,
            verbose=True,
        )

categorizer:
  role: >
    Email threads categorizer
  goal: >
    Automatically categorize email threads based on their content.
  backstory: >
    You're a virtual assistant with a knack for organizing information.
    You're known for your ability to quickly and accurately categorize email
    threads, so that your clients know which ones are important to answer
    and which ones are spam, newsletters, or other types of messages that
    do not require attention.
    Available categories: QUESTION, NOTIFICATION, NEWSLETTER, SPAM. Do not make
    up new categories.

response_writer:
  role: >
    Email response writer
  goal: >
    Write clear and concise responses to an email thread. Try to help the
    sender. Use the external knowledge base to provide relevant information.
  backstory: >
    You are a professional writer with a talent for crafting concise and
    informative responses. You're known for your ability to quickly understand
    the context of an email thread and provide a helpful and relevant response
    that addresses the sender's needs. You always rely on your knowledge base
    to provide accurate and up-to-date information.

categorization_task:
  description: >
    Review the content of the following email thread and categorize it 
    into the appropriate category. There might be multiple categories that
    apply to the email thread.
    
    <messages>{messages}</messages>
  expected_output: >
    A list of all the categories that the email threads can be classified into.
  agent: categorizer

response_writing_task:
  description: >
    Write a response to the following email thread. The response should be
    clear, concise, and helpful to the sender. Always rely on the Qdrant search
    tool, so you can get the most relevant information to craft your response.
    Please try to include the source URLs of the information you provide.
    
    Only focus on the real question asked by the sender and do not try to 
    address any other issues that are not directly related to the sender's needs.
    Do not try to provide a response if the context is not clear enough.
    
    <messages>{messages}</messages>
  expected_output: >
    A well-crafted response to the email thread that addresses the sender's needs.
    Please use simple HTML formatting to make the response more readable.
    Do not include greetings or signatures in your response, but provide the footnotes
    with the source URLs of the information you used, if possible.
    
    If the provided context does not give you enough information to write a response,
    you must admit that you cannot provide a response and write "I cannot provide a response.".
  agent: response_writer