DeepSearch unter Verwendung von visuellem RAG in agentenbasierten Frameworks

Agentische Systeme sind für die Gestaltung heutiger KI-Systeme von besonderer Bedeutung, da sie sich präzise an die Anforderungen der Nutzer anpassen und die richtigen Werkzeuge zur Lösung eines Problems einsetzen können. Bei ILLUIN Technology untersuchen und entwickeln wir diese Systeme insbesondere mithilfe von nAIxt, unserer Low-Code-Plattform für generative KI.

Heute untersuchen wir, wie visuelle Abrufmethoden – wie beispielsweise ColPali – Retrieval-Augmented-Generation-Systeme (RAG) erheblich verbessern können, insbesondere wenn sie in agentenbasierte Umgebungen integriert werden. Diese Fortschritte verbessern die Abrufqualität, allerdings auf Kosten einer erhöhten Rechenzeit während der Testphase.

Unser Tool ist auf HuggingFace verfügbar!

RAG verstehen

Retrieval-Augmented Generation (RAG) erweitert die Fähigkeiten großer Sprachmodelle (LLMs), indem relevante externe Informationen abgerufen werden, um den Generierungsprozess zu unterstützen. Herkömmliche RAG-Systeme zeichnen sich in der Regel durch folgende Merkmale aus:

1. Rufen Sie relevante Informationen aus einem Wissenskorpus basierend auf der Anfrage eines Benutzers ab.
2. Fügen Sie diesen Kontext vor der ursprünglichen Abfrage ein.
3. Leiten Sie die angereicherte Abfrage an ein LLM weiter, um die Antwort zu generieren. Hier ist eine Darstellung einer Standard-RAG-Pipeline:

Der Aufstieg von Visual RAG

Eine spannende Erweiterung von RAG ist Visual RAG, das besonders in Dokumenten-QA-Szenarien von Vorteil ist. Herkömmliche Dokumenten-QA-Methoden basieren oft auf komplexen Pipelines, die optische Zeichenerkennung (OCR) und Dokumentenlayout-Erkennung umfassen. Die aktuelle Veröffentlichung ColPali: Efficient Document Retrieval with Vision Language Models zeigt jedoch, wie Vision-Language-Modelle (VLMs) wie ColPali diesen Prozess optimieren können, indem sie Screenshots von Dokumentseiten direkt einbetten und so die Notwendigkeit von Text-Extraktions-Pipelines beseitigen. Dies führt sowohl zu einer verbesserten Recheneffizienz als auch zu einer insgesamt besseren Suchleistung.

Einschränkungen aktueller RAG-Systeme

Trotz dieser Fortschritte weisen traditionelle RAG-Systeme (visuell oder textuell) nach wie vor erhebliche Einschränkungen auf:

• Abfrageempfindlichkeit: Systeme reagieren übermäßig empfindlich auf die Formulierung von Abfragen, wodurch möglicherweise relevante Informationen übersehen werden, wenn sich der Abfragestil vom Inhalt des Korpus unterscheidet.
• Single-Hop-Abruf: Typische RAG-Systeme führen nur einen Abrufschritt durch, wodurch ihre Fähigkeit zur Bearbeitung komplexer Abfragen, die Informationen aus mehreren Dokumentabschnitten erfordern (z. B. Verweise auf mehrere Tabellen oder verstreute Definitionen), eingeschränkt ist. Bisherige Versuche, diese Herausforderungen zu bewältigen, haben nur zu geringfügigen Verbesserungen geführt.

Enter Agentic RAG

Eine vielversprechende Lösung für diese Einschränkungen besteht darin, Retriever in agentenbasierte Frameworks zu integrieren:

In agentenbasierten Umgebungen gewinnen RAG-Systeme erheblich an Flexibilität:

• Interaktive Abfrageverarbeitung: Agenten formulieren Abfragen dynamisch in mehrere Unterabfragen um.
• Iterative Retrieval: Agenten führen mehrere Abrufrunden durch und synthetisieren dabei schrittweise Informationen, bis eine umfassende und zufriedenstellende Antwort erzielt wird.
• Verwendung externer Tools: Agenten können externe Tools wie die Websuche verwenden und auch Code generieren und ausführen, wodurch sie mathematische Operationen durchführen, Diagramme erstellen usw. können. Dieser iterative, agentenbasierte Ansatz gewährleistet reichhaltigere, tiefgreifendere und kontextuell genauere Antworten und verbessert Visual-RAG-Systeme wie ColPali erheblich.

Entwurf eines visuellen RAG-Agenten

Lassen Sie uns Schritt für Schritt einen einfachen Visual RAG Agent erstellen, indem wir verwenden smolagents.

Agenten arbeiten effektiv, indem sie speziell auf ihre Ziele zugeschnittene Tools einsetzen. Um dies zu veranschaulichen, haben wir ein spezielles Visual RAG Tool entwickelt.

Konkret erstellen wir unser Tool, indem wir eine benutzerdefinierte Klasse erstellen, die von smolagents.Tool.

Zuerst definieren wir die Klasse und überschreiben die setup Methode, die zur Vorbereitung des Werkzeugs vor dem Gebrauch verwendet wird.

class VisualRAGTool(Tool):
    name = "visual_rag"
    description = """Performs a RAG query on your internal PDF documents and returns the generated text response."""
    inputs = {...}
    output_type = "string"

  def _init_models(self, model_name: str) -> None:
      import torch
      from colpali_engine.models import ColQwen2, ColQwen2Processor

      self.device = "cuda" if torch.cuda.is_available() else "cpu"

      # Init the model and processor
      self.model = ColQwen2.from_pretrained(
              model_name,
              torch_dtype=torch.bfloat16,
              device_map="auto",
              attn_implementation="flash_attention_2"
          ).eval()
      self.processor = ColQwen2Processor.from_pretrained(model_name)

  def setup(self):
      """
      Overwrite this method here for any operation that is expensive and needs to be executed before you start using your tool. Such as loading a big model.
      """
      # Init the models
      self._init_models(self.model_name)

      # Initialize the DBs
      self.embds = []
      self.pages = []

      self.is_initialized = True

Als Nächstes definieren wir unsere Indizierungsmethode, indem wir eine Funktion erstellen: index, das die Attribute self.pages und self.embds.

def index(self, files: list, contextualize: bool = True, api_key: str = None) -> int:
    """Indexes the uploaded files."""
    if not self.is_initialized:
        self.setup()

    # Convert files to images and extract metadata
    pgs = self.preprocess(files, contextualize=contextualize, api_key=api_key or self.api_key)

    # Embed the images
    embds = self.compute_embeddings(pgs)

    # Extend the pages
    self.pages.extend(pgs)
    self.embds.extend(embds)

    return len(embds)

Hier preprocess kümmert sich um die Konvertierung von Dateien in den Typ Page die ein Dokumentenseitenbild zusammen mit Metadaten darstellen. Anschließend werden die Seiten eingebettet und in den Attributen gespeichert.

⚠️ Hier verwenden wir eine sehr einfache Strategie. Die Indizierung mit einer VectorDB anstelle von Arrays könnte die Leistung des Tools verbessern!

Schließlich müssen wir die Hauptfunktion des Tools definieren: forward. In unserem Fall forward ist die Funktion, die die gesamte RAG-Pipeline ausführt und die LLM-Antwort zurückgibt.

def forward(self, query: str, k: int = 1, api_key: str = None) -> str:
    assert isinstance(query, str), "Your search query must be a string"

    # Retrieve the top k documents and generate response. We return the second element of the tuple only (the RAG answer)
    return self.search(
        query=query, 
        k=k, 
        api_key=api_key
    )[1]

def search(self, query: str, k: int = 1, api_key: str = None) -> tuple:
    """Searches for the most relevant pages based on the query."""
    # Retrieve the top k documents
    context = self.retrieve(query, k)

    # Generate response from GPT-4o-mini
    rag_answer = self.generate_answer(
        query=query, 
        docs=context, 
        api_key=api_key
    )

    return context, rag_answer.content

Beachten Sie, dass wir eine Zwischenfunktion verwenden, search, um auf den abgerufenen Kontext zuzugreifen. Die Tool-Klasse erlaubt jedoch nur die Rückgabe eines Typs!

Visual RAG Tool in Aktion

Testen wir unser Tool!

Zunächst indizieren wir unseren gesamten Dokumentenkorpus mit ColQwen2. Wenn das System dann zur Laufzeit eine Anfrage erhält, nutzt es ColQwen2, um die k relevantesten Dokumentenseiten abzurufen. Diese abgerufenen Seiten werden zusammen mit zusätzlichem Kontext an GPT-4o-mini weitergeleitet, das eine Textantwort generiert, die direkt auf die Anfrage des Benutzers eingeht. Besonderes Augenmerk wird darauf gelegt, dass GPT-4o-mini genau die Seiten und Dokumente zitiert, die zur Formulierung jeder Antwort verwendet wurden. Unser Tool ist auf HuggingFace verfügbar. Veranschaulichen wir dies anhand eines praktischen Beispiels aus einem von der Europäischen Kommission herausgegebenen Jugendmagazin, das sich mit der Wissenschaft des Klimawandels befasst.

So einfach ist die Anwendung:

from smolagents import load_tool
# Load the visual RAG tool
visual_rag_tool = load_tool(
    "vidore/visual-rag-tool",
    trust_remote_code=True,
    api_key="YOUR_OPENAI_KEY"
)

# Index the PDF document
visual_rag_tool.index(["./report.pdf"])

# Query the tool
visual_rag_tool("What share of the world's water is suitable for human consumption?", k=3)

Und hier ist die informative Antwort, die wir erhalten haben:

Nur 2,5 % des Wassers auf der Erde sind Süßwasser. Von diesem Süßwasser sind mehr als zwei Drittel in Gletschern und Polkappen gefroren und somit für den Verbrauch weitgehend unzugänglich. Daher ist der Anteil des Wassers, das für den menschlichen Verbrauch geeignet ist, minimal [1, S. 11].

Quellen:
[1] climate_youth_magazine.pdf

Wie gezeigt, liefert das Visual RAG Tool präzise Antworten und zitiert dabei genau seine Quellen. Probieren Sie ruhig weiter mit einer unterschiedlichen Anzahl von Seiten aus (k) für den Kontext.

Integration des Tools in ein agentenbasiertes Framework

DeepSearch ist ein neuartiges KI-Framework, in dem Agenten komplexe, mehrstufige Rechercheaufgaben ausführen, um die Anfragen der Benutzer umfassend zu beantworten. Wenn ein Agent eine Anfrage erhält, erstellt er einen strukturierten Plan, in dem er die Frage aufschlüsselt und strategisch Suchvorgänge in verschiedenen vertrauenswürdigen Quellen und externen Tools durchführt.

Eine besonders vielversprechende Richtung ist die Integration unseres Visual-RAG-Tools in ein DeepSearch-Framework. Der Hauptvorteil der Kombination von Visual RAG mit Orchestrierungsagenten, die über einen größeren Handlungsspielraum verfügen, besteht darin, dass sie die Benutzerabfrage aufschlüsseln und alle notwendigen Schritte unabhängig voneinander lösen können, um komplexe Antworten zu generieren, die alle erforderlichen Einschränkungen berücksichtigen.

So könnte eine mit Visual RAG erweiterte DeepSearch-Konfiguration aussehen:

In diesem Setup fungiert der QA-Agent als Koordinator, der eingehende Anfragen bearbeitet und die beste Antwort auf die Anfrage plant, indem er mit unserem visuellen RAG-Tool und zwei spezialisierten Agenten interagiert:

• Web Verifier Agent: Vergleicht intern abgerufene Informationen mit externen Webquellen und weist ihnen einen Vertrauenswert zu, um Genauigkeit und Zuverlässigkeit sicherzustellen.
• Formatter Agent: Verbessert Antworten hinsichtlich Klarheit und Lesbarkeit, strukturiert sie effektiv für den Benutzer und visualisiert möglicherweise wichtige Datenerkenntnisse.

Erstellen des QA-Agenten mit smolagents

Wir haben diesen Orchestrator mithilfe des benutzerfreundlichen Frameworks implementiert. smolagents. So richten Sie es praktisch ein, indem Sie unser zuvor erstelltes Visual RAG Tool anschließen:

from smolagents import CodeAgent, DuckDuckGoSearchTool
from smolagents import OpenAIServerModel

gpt_4o_mini = OpenAIServerModel(
    model_id="gpt-4o-mini",
    api_base="https://api.openai.com/v1",
    api_key="YOUR_API_KEY",
)

# Define the verifier agent
VERIFIER_AGENT = CodeAgent(
    tools=[
        DuckDuckGoSearchTool(),
    ],
    model=gpt_4o_mini,
    max_steps=6,
    verbosity_level=2,
    planning_interval=3,
    name="verifier",
    description=\
        """This agent takes the user query as an input, associated information and context found by the previous agent, and must output a response that confirms the veracity of the previous agent's response using web searches.
           The verifier should provide a confidence score (high, medium, low) and a textual explanation of the confidence score.
            If the verifier cannot find relevant information, it should state it as 'unverified'."""
)

# Define the formatter agent
FORMATTER_AGENT = CodeAgent(
    tools=[
        DuckDuckGoSearchTool(),
    ],
    model=gpt_4o_mini,
    max_steps=3,
    verbosity_level=2,
    planning_interval=1,
    name="formatter",
    description=\
        """This agent takes the agent's response as an input and must output a formatted response that is easy to read and understand.
            The response should follow the user's specifications and be as clear as possible.
            The agent can ask for additional information if needed."""
)

Mit diesen können wir unsere QA_AGENT wo wir die visual_rag_tool vorher erstellt.

gpt_4o = OpenAIServerModel(
    model_id="gpt-4o",
    api_base="https://api.openai.com/v1",
    api_key="YOUR_API_KEY",,
)

# Define the QA Agent
QA_AGENT = CodeAgent(
        name="qa_agent",
        description=\
        """The agent takes a user query as input and is tasked with providing a detailed response to the query. 
            It uses internal documents via the RAG Tool as its first source of informations to answer the questions. It can use external sources (such as web searches) only as a fallback when no relevant information is found within the internal sources.
           Once the agent has gathered the information, it will assess the confidence level in the sources found using the `verifier` agent. This confidence score will be included in the final response to give the user an understanding of how reliable the provided information is.
           The final response should be detailed and cite the information sources. It should follow the format specified by the user using the `formatter` agent.""",
        tools=[
            visual_rag_tool,
            DuckDuckGoSearchTool(),
        ],
        managed_agents=[
            VERIFIER_AGENT, 
            FORMATTER_AGENT
        ],
        model=gpt_4o,
        max_steps=10,
        verbosity_level=2,
        planning_interval=3,
        add_base_tools=True,
        additional_authorized_imports=["pandas", "seaborn", "numpy", "matplotlib", "PIL", "io"],
    )

Einige Anmerkungen hierzu:

• DuckDuckGoSearchTool ist das Tool für die Online-Suche. Es wird vom Webbrowser unterstützt. DuckDuckGo
• Die description Feld der CodeAgent Die Klasse ist entscheidend, da sie den Zweck des Agenten im Ökosystem beschreibt. Sie hilft anderen Agenten bei der Planung von Aufrufen an diesen.
• max_steps begrenzt die Anzahl der Suchschritte für den Agenten, während planning_interval legt das Intervall fest, in dem der Agent einen Planungsschritt ausführt. Sie können diese Werte nach Bedarf ändern.
• Wir wählen aus gpt-4o und gpt-4o-mini als unsere Backbone-LLMs für die Agenten, aber Sie können gerne auch alle von smolagents unterstützten Modelle.

Nun wollen wir sehen, wie das System funktioniert. Wir verwenden dieselbe Abfrage, die wir zuvor an das RAG-Tool gestellt haben.

Ausgabe:

Unter Bezugnahme auf interne und externe Quellen wurde festgestellt, dass weniger als 1 % des gesamten Wassers der Erde für den menschlichen Verbrauch geeignet ist. Dieser Anteil ergibt sich aus der Tatsache, dass nur 2,5 % des Wassers der Erde Süßwasser sind und der größte Teil davon in Gletschern, Polkappen oder unzugänglichem Grundwasser gebunden ist [1]. Externe Quellen bestätigen dies und legen nahe, dass nur etwa 0,5 % bis 1 % des gesamten Wassers der Erde für den menschlichen Verzehr genutzt werden können. Die Schlussfolgerung ist sehr zuverlässig und weist einen hohen Konfidenzwert auf, wie durch die Verifizierungsaufgabe bestätigt wurde.

Quellen

1. Climate Youth Magazine. „Wasserversorgung: Fakten und Auswirkungen.“ PDF-Dokument, S. 11.
2. U.S. Bureau of Reclamation. „Water Facts – Worldwide Water Supply.“ Zugriff im Oktober 2023. https://www.usbr.gov/mp/arwec/water-facts-ww-water-sup.html
3. World Water Reserve. „Wie hoch ist der Anteil an Trinkwasser auf der Erde?“ Zugriff im Oktober 2023. https://worldwaterreserve.com/percentage-of-drinkable-water-on-earth/

Fazit

Der Anteil des weltweiten Wasservorkommens, das für den menschlichen Verzehr geeignet ist, wird auf 0,5 % bis 1 % geschätzt. Angesichts der Zuverlässigkeit der zitierten Quellen und des angewandten Überprüfungsprozesses weist die Antwort ein hohes Maß an Genauigkeit und Glaubwürdigkeit auf und bestätigt den relativ geringen Anteil an Wasser, der für den menschlichen Gebrauch verfügbar ist, im Vergleich zu den riesigen Reserven auf der Erde.

The answer is much more detailed than with the tool only! - The agent used a step to estimate the percentage of water suitable for consumption (<1%) given that 2.5% is fresh water among which more than 2/3 is trapped in ice. - The verifier provided external sources to validate the findings along with a confidence label. Now let's use the agent memory and capabilities to create plots to ask it to produce a plot based on the answer.

Hier ist die damit erstellte Grafik:

Die Darstellung ist laut interner Quelle korrekt. Sie könnte jedoch durch eine detailliertere und präzisere Eingabeaufforderung erheblich verbessert werden. Beispielsweise fand das Modell relevante Daten im Internet, verwendete diese jedoch nicht in seiner Darstellung, um sich ausschließlich auf interne Quellen zu konzentrieren.

Abschließende Gedanken

Die Integration der visuellen Suche in ein agentenbasiertes DeepSearch-Framework mit Quellenüberprüfung birgt erhebliches Potenzial. Dieser Ansatz behebt wesentliche Einschränkungen herkömmlicher RAG-Systeme – wie die Empfindlichkeit gegenüber Suchanfragen und die Single-Hop-Suche –, indem ein Agent als Koordinator eingesetzt wird. Der Agent kann RAG-Suchanfragen automatisch verfeinern, Quellen überprüfen und Ergebnisse strukturiert präsentieren.

Dieser Ansatz ist jedoch noch lange nicht perfekt... Agentische Systeme sind in der Regel langsamer, können in unnötigen Schleifen hängen bleiben und weichen manchmal von der ursprünglichen Absicht des Benutzers ab. Der Orchestrator scheint sehr empfindlich auf Eingaben zu reagieren. Mit der Weiterentwicklung und Verbesserung der zugrunde liegenden Modelle erwarten wir, dass diese Probleme gemildert werden.

Dieser Blogbeitrag gibt einen kurzen Einblick in die visuelle agentenbasierte RAG, aber das ist erst der Anfang! Wir empfehlen Ihnen, das Tool selbst zu testen und benutzerdefinierte Agenten für Ihre verschiedenen Anwendungsfälle zu erstellen. Teilen Sie uns gerne Ihre Erfahrungen mit, wir sind sehr gespannt darauf, was Sie entwickeln werden!

Kontakt

Fachleute, die an tiefergehenden Diskussionen und Projekten rund um Visual RAG, ColPali oder agentenbasierte Systeme interessiert sind, können sich gerne an contact@illuin.tech wenden und unsere Experten bei ILLUIN kontaktieren, die Ihnen dabei helfen können, Ihre KI-Projekte voranzutreiben!