CrewAI: Spezialisierte Teams von RAG-Agenten

CrewAI ist ein Python-Framework zur Orchestrierung von Teams autonomer KI-Agenten. Jeder Agent hat eine spezifische Rolle mit dedizierten Kompetenzen und Werkzeugen. Gemeinsam arbeiten sie zusammen, um komplexe Aufgaben wie fortgeschrittenes RAG zu bewältigen.

Voraussetzungen: Lesen Sie unseren Leitfaden zur Orchestrierung von RAG-Agenten, um die Grundlagen zu verstehen.

Warum CrewAI für RAG?

Der "Team"-Ansatz

CrewAI modelliert Teams wie in der realen Welt: Jedes Mitglied hat eine Rolle, Kompetenzen und spezifische Werkzeuge.

ARCHITECTURE CREWAI

┌────────────────────────────────────────────────────┐
│                      CREW                           │
├────────────────────────────────────────────────────┤
│                                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐  │
│  │   AGENT 1    │  │   AGENT 2    │  │  AGENT 3 │  │
│  │  Researcher  │  │   Analyst    │  │  Writer  │  │
│  ├──────────────┤  ├──────────────┤  ├──────────┤  │
│  │ Role: Search │  │ Role: Verify │  │Role:Write│  │
│  │ Goal: Find   │  │ Goal: Check  │  │Goal:Draft│  │
│  │ Tools: RAG   │  │ Tools: None  │  │Tools:None│  │
│  └──────┬───────┘  └──────┬───────┘  └────┬─────┘  │
│         │                 │               │        │
│         ▼                 ▼               ▼        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐  │
│  │   TASK 1     │  │   TASK 2     │  │  TASK 3  │  │
│  │  Research    │  │   Analysis   │  │  Writing │  │
│  │  documents   │  │   & verify   │  │  response│  │
│  └──────────────┘  └──────────────┘  └──────────┘  │
│                                                    │
└────────────────────────────────────────────────────┘

Vergleich mit anderen Frameworks

Vorteile von CrewAI

• Einfachheit: Intuitive API basierend auf vertrauten Konzepten (Rollen, Aufgaben)
• Modularität: Wiederverwendbare Agenten zwischen verschiedenen Crews
• Delegation: Agenten können automatisch untereinander delegieren
• Werkzeuge: Einfache Integration benutzerdefinierter Tools

Grundlegende Konzepte

Agents, Tasks und Crew

DEVELOPERpython
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# LLM-Konfiguration
llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

# 1. Definition der Agenten
researcher = Agent(
    role="Leitender Dokumentationsrechercheur",
    goal="Praezise und relevante Informationen zum angefragten Thema finden",
    backstory="""Du bist ein erfahrener Rechercheur mit 10 Jahren Erfahrung
    in der Analyse technischer Dokumente. Du bist besonders gut darin,
    Schluesselinformationen zu extrahieren und zuverlaessige Quellen zu identifizieren.
    Du gibst dich nicht mit den ersten Ergebnissen zufrieden und vertiefst
    deine Recherchen stets.""",
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

analyst = Agent(
    role="Content-Analyst",
    goal="Gefundene Informationen synthetisieren und verifizieren",
    backstory="""Du bist ein kritischer Analyst mit Expertise
    in der Faktenpruefung. Du identifizierst Widersprueche,
    bewertest die Zuverlaessigkeit von Quellen und strukturierst Informationen
    logisch.""",
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

writer = Agent(
    role="Technischer Redakteur",
    goal="Klare, strukturierte und gut belegte Antworten produzieren",
    backstory="""Du bist ein technischer Redakteur mit Expertise
    in verstaendlicher Wissensvermittlung. Du wandelst komplexe Informationen
    in zugaengliche, ansprechende Inhalte um und wahrst dabei
    die technische Praezision.""",
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

# 2. Definition der Tasks
research_task = Task(
    description="""Recherchiere Informationen zu: {topic}

    Du musst:
    1. Die Schluesselkonzepte zum Thema identifizieren
    2. In der Wissensdatenbank recherchieren
    3. 3-5 relevante Quellen sammeln
    4. Die wichtigsten Informationen aus jeder Quelle extrahieren
    5. Unsichere oder umstrittene Punkte notieren

    Liefere einen strukturierten Bericht mit Quellen und Schluesselauszuegen.""",
    expected_output="""Rechercheberichtenthaltend:
    - Liste der identifizierten Schluesselkonzepte
    - Fuer jede Quelle: Titel, relevanter Auszug, Relevanz-Score
    - Unsicherheitspunkte oder Punkte, die eine Verifizierung erfordern""",
    agent=researcher,
)

analysis_task = Task(
    description="""Analysiere die vom Rechercheur bereitgestellten Dokumente.

    Du musst:
    1. Die Konsistenz zwischen den Quellen pruefen
    2. Durch mehrere Quellen bestaetigte Informationen identifizieren
    3. Etwaige Widersprueche melden
    4. Das Vertrauensniveau fuer jede Information bewerten
    5. Die Informationen nach Thema organisieren

    Erstelle eine strukturierte Synthese mit Vertrauensniveaus.""",
    expected_output="""Analytische Synthese enthaltend:
    - Bestaetigte Informationen (hohes Vertrauen)
    - Einzigartige Informationen (mittleres Vertrauen)
    - Identifizierte Widersprueche
    - Empfehlungen fuer die Redaktion""",
    agent=analyst,
    context=[research_task],  # Abhaengig von der Recherche
)

writing_task = Task(
    description="""Verfasse eine vollstaendige Antwort basierend auf der Analyse.

    Du musst:
    1. Die vom Analysten validierten Informationen verwenden
    2. Die Antwort mit Einleitung, Hauptteil, Schluss strukturieren
    3. Quellen in eckigen Klammern zitieren [Quelle X]
    4. Das Detailniveau an den Kontext anpassen
    5. Grenzen oder Unsicherheiten bei Bedarf angeben

    Die Antwort muss professionell und gut formatiert sein.""",
    expected_output="""Strukturierte Antwort von 300-500 Woertern enthaltend:
    - Einleitung, die das Thema einordnet
    - Hauptteil mit Schluesselinformationen und Zitaten
    - Zusammenfassender Schluss
    - Liste der verwendeten Quellen""",
    agent=writer,
    context=[research_task, analysis_task],
)

# 3. Erstellung der Crew
crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    process=Process.sequential,  # Sequentielle Ausfuehrung
    verbose=True,
)

# 4. Ausfuehrung
result = crew.kickoff(inputs={"topic": "Was ist RAG und wie implementiert man es?"})
print(result)

RAG-Integration mit CrewAI

Benutzerdefinierte Suchwerkzeuge

DEVELOPERpython
from crewai_tools import BaseTool
from typing import Type
from pydantic import BaseModel, Field
import json

class SearchInput(BaseModel):
    """Eingabeschema fuer die Suche."""
    query: str = Field(description="Die Suchanfrage")
    top_k: int = Field(default=5, description="Anzahl der Ergebnisse")

class VectorSearchTool(BaseTool):
    """Vektorsuche-Werkzeug fuer CrewAI."""

    name: str = "search_knowledge_base"
    description: str = """Durchsucht Dokumente in der Wissensdatenbank.
    Nutze dieses Werkzeug, um relevante Informationen zu einem Thema zu finden."""
    args_schema: Type[BaseModel] = SearchInput

    def __init__(self, vector_store):
        super().__init__()
        self._vector_store = vector_store

    def _run(self, query: str, top_k: int = 5) -> str:
        """Fuehrt die Suche aus."""
        results = self._vector_store.similarity_search(query, k=top_k)

        if not results:
            return "Kein relevantes Dokument fuer diese Anfrage gefunden."

        output = "Gefundene Dokumente:\n\n"
        for i, doc in enumerate(results, 1):
            output += f"[Quelle {i}]\n"
            output += f"Inhalt: {doc.page_content[:500]}...\n"
            if doc.metadata:
                output += f"Metadaten: {doc.metadata}\n"
            output += "\n"

        return output


class FactVerificationTool(BaseTool):
    """Werkzeug zur Faktenpruefung."""

    name: str = "verify_fact"
    description: str = """Prueft eine Aussage gegen die verfuegbaren Quellen.
    Nutze dieses Werkzeug, um eine Behauptung zu bestaetigen oder zu widerlegen."""

    def __init__(self, vector_store):
        super().__init__()
        self._vector_store = vector_store

    def _run(self, claim: str) -> str:
        """Prueft eine Behauptung."""
        results = self._vector_store.similarity_search(claim, k=3)

        if not results:
            return json.dumps({
                "claim": claim,
                "status": "unverified",
                "confidence": 0,
                "reason": "Keine Quelle gefunden"
            })

        # Einfache Konsistenzanalyse
        return json.dumps({
            "claim": claim,
            "status": "found_sources",
            "sources_count": len(results),
            "sources": [doc.page_content[:200] for doc in results]
        })


# Erstellung der Werkzeuge
search_tool = VectorSearchTool(vector_store)
verify_tool = FactVerificationTool(vector_store)

# Agent mit RAG-Werkzeugen
rag_researcher = Agent(
    role="RAG-Experte",
    goal="Informationen in der Wissensdatenbank recherchieren und verifizieren",
    backstory="""Du bist ein Experte fuer Dokumentenrecherche.
    Du nutzt systematisch die Suchwerkzeuge, um
    die relevantesten und zuverlaessigsten Informationen zu finden.""",
    tools=[search_tool, verify_tool],
    llm=llm,
    verbose=True,
)

Vollständige RAG-Crew

DEVELOPERpython
from crewai import Agent, Task, Crew, Process

# Spezialisierte Agenten fuer RAG
query_analyst = Agent(
    role="Anfrage-Analyst",
    goal="Fragen zerlegen und umformulieren, um die Suche zu optimieren",
    backstory="""Du analysierst die Fragen der Nutzer, um
    Schluesselkonzepte zu identifizieren und effiziente Suchvarianten zu generieren.
    Du erkennst Mehrdeutigkeiten und klaerst sie.""",
    llm=llm,
    verbose=True,
)

document_searcher = Agent(
    role="Dokumentationsrechercheur",
    goal="Die relevantesten Dokumente finden",
    backstory="""Du bist Experte fuer Dokumentenrecherche.
    Du nutzt verschiedene Suchstrategien, um
    die Relevanz der Ergebnisse zu maximieren.""",
    tools=[search_tool],
    llm=llm,
    verbose=True,
)

fact_checker = Agent(
    role="Faktenpruefer",
    goal="Die Genauigkeit der Informationen ueberpruefen",
    backstory="""Du prueft jede Behauptung gegen die Quellen.
    Du identifizierst Inkonsistenzen und moegliche Fehler.""",
    tools=[verify_tool],
    llm=llm,
    verbose=True,
)

response_generator = Agent(
    role="Antwortgenerator",
    goal="Vollstaendige und gut belegte Antworten erstellen",
    backstory="""Du synthetisierst die gefundenen Informationen
    zu klaren, strukturierten Antworten mit Quellenangaben.""",
    llm=llm,
    verbose=True,
)

# Tasks der RAG-Pipeline
analyze_query_task = Task(
    description="""Analysiere diese Frage: {question}

    1. Identifiziere die Schluesselkonzepte
    2. Generiere 2-3 Umformulierungen fuer die Suche
    3. Identifiziere den Fragetyp (faktisch, analytisch, vergleichend)
    4. Liste die zur Beantwortung erforderlichen Informationen auf""",
    expected_output="Strukturierte Analyse der Frage mit Umformulierungen",
    agent=query_analyst,
)

search_documents_task = Task(
    description="""Recherchiere die relevanten Dokumente.

    Nutze die Fragenanalyse, um:
    1. Mehrere Suchen mit den Umformulierungen durchzufuehren
    2. Mindestens 5 relevante Dokumente zu sammeln
    3. Die Schluesselpassagen jedes Dokuments zu extrahieren""",
    expected_output="Liste von Dokumenten mit relevanten Auszuegen",
    agent=document_searcher,
    context=[analyze_query_task],
)

verify_facts_task = Task(
    description="""Ueberpruefe die gefundenen Informationen.

    Fuer jede Schluesselinformation:
    1. Pruefe die Konsistenz zwischen den Quellen
    2. Identifiziere Widersprueche
    3. Weise ein Vertrauensniveau zu""",
    expected_output="Verifizierungsbericht mit Vertrauensniveaus",
    agent=fact_checker,
    context=[search_documents_task],
)

generate_response_task = Task(
    description="""Generiere die finale Antwort.

    Nutze die verifizierten Informationen, um:
    1. Die Antwort klar zu strukturieren
    2. Quellen zu zitieren [Quelle X]
    3. Unsicherheiten bei Bedarf anzugeben""",
    expected_output="Strukturierte finale Antwort mit Zitaten",
    agent=response_generator,
    context=[search_documents_task, verify_facts_task],
)

# RAG-Crew
rag_crew = Crew(
    agents=[query_analyst, document_searcher, fact_checker, response_generator],
    tasks=[analyze_query_task, search_documents_task, verify_facts_task, generate_response_task],
    process=Process.sequential,
    verbose=True,
)

def answer_question(question: str) -> str:
    """Beantwortet eine Frage ueber die RAG-Crew."""
    result = rag_crew.kickoff(inputs={"question": question})
    return result

Fortgeschrittene Patterns

Pattern 1: Hierarchische Crew

Ein Manager beaufsichtigt die spezialisierten Agenten und delegiert an sie:

DEVELOPERpython
from crewai import Agent, Task, Crew, Process

# Hauptmanager
project_manager = Agent(
    role="RAG-Projektleiter",
    goal="Das Team koordinieren, um qualitativ hochwertige Antworten zu produzieren",
    backstory="""Du beaufsichtigst die Recherche- und Redaktionsteams.
    Du delegierst die passenden Aufgaben an die richtigen Agenten und
    validierst die Qualitaet der Ergebnisse.""",
    llm=llm,
    allow_delegation=True,  # Kann delegieren
    verbose=True,
)

# Hauptaufgabe
main_task = Task(
    description="""Beantworte diese Frage vollstaendig: {question}

    Du musst das Team koordinieren, um:
    1. Die relevanten Informationen zu recherchieren
    2. Die Ergebnisse zu verifizieren und zu analysieren
    3. Eine qualitativ hochwertige Antwort zu produzieren

    Delegiere die Aufgaben an die spezialisierten Agenten.""",
    expected_output="Vollstaendige, verifizierte und gut strukturierte Antwort",
    agent=project_manager,
)

# Hierarchische Crew
hierarchical_crew = Crew(
    agents=[project_manager, document_searcher, fact_checker, response_generator],
    tasks=[main_task],
    process=Process.hierarchical,  # Hierarchischer Modus
    manager_agent=project_manager,
    verbose=True,
)

Pattern 2: Crew mit Gedächtnis

Agenten, die den Kontext zwischen Anfragen beibehalten:

DEVELOPERpython
from crewai import Agent, Task, Crew
from crewai.memory import ShortTermMemory, LongTermMemory, EntityMemory

# Speicherkonfiguration
short_memory = ShortTermMemory()
long_memory = LongTermMemory()
entity_memory = EntityMemory()

# Agent mit Gedaechtnis
memory_researcher = Agent(
    role="Rechercheur mit Gedaechtnis",
    goal="Unter Nutzung des Kontexts vorheriger Interaktionen recherchieren",
    backstory="""Du erinnerst dich an vorherige Recherchen
    und nutzt diesen Kontext, um deine Ergebnisse zu verbessern.
    Du vermeidest es, dieselben Recherchen zu wiederholen.""",
    llm=llm,
    memory=True,
    verbose=True,
)

# Crew mit geteiltem Gedaechtnis
memory_crew = Crew(
    agents=[memory_researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    memory=True,
    short_term_memory=short_memory,
    long_term_memory=long_memory,
    entity_memory=entity_memory,
    verbose=True,
)

Pattern 3: Bedingte Crew

Bedingte Ausfuehrung basierend auf den Ergebnissen:

DEVELOPERpython
from crewai import Agent, Task, Crew, Process

class ConditionalRAGCrew:
    """Crew mit bedingter Logik."""

    def __init__(self, llm, vector_store):
        self.llm = llm
        self.vector_store = vector_store
        self._setup_agents()
        self._setup_tasks()

    def _setup_agents(self):
        self.classifier = Agent(
            role="Fragen-Klassifikator",
            goal="Den Fragetyp und die Strategie bestimmen",
            backstory="Du analysierst Fragen, um die Verarbeitung zu steuern.",
            llm=self.llm,
        )

        self.simple_responder = Agent(
            role="Einfacher Beantworter",
            goal="Einfache faktische Fragen beantworten",
            backstory="Du beantwortest direkte Fragen schnell.",
            llm=self.llm,
        )

        self.complex_responder = Agent(
            role="Komplexer Beantworter",
            goal="Fragen behandeln, die eine gruendliche Analyse erfordern",
            backstory="Du behandelst komplexe Fragen mit Sorgfalt.",
            llm=self.llm,
        )

    def _setup_tasks(self):
        self.classify_task = Task(
            description="""Klassifiziere diese Frage: {question}

            Moegliche Typen:
            - simple: Direkte faktische Frage
            - complex: Erfordert Recherche und Analyse
            - comparative: Vergleicht mehrere Elemente

            Antworte nur mit dem Typ.""",
            expected_output="Fragetyp (ein Wort)",
            agent=self.classifier,
        )

    def process(self, question: str) -> dict:
        """Verarbeitet eine Frage mit bedingter Logik."""
        # Phase 1: Klassifizierung
        classify_crew = Crew(
            agents=[self.classifier],
            tasks=[self.classify_task],
            process=Process.sequential,
        )
        classification = classify_crew.kickoff(inputs={"question": question})

        question_type = classification.strip().lower()

        # Phase 2: Bedingte Verarbeitung
        if question_type == "simple":
            return self._process_simple(question)
        else:
            return self._process_complex(question)

    def _process_simple(self, question: str) -> dict:
        simple_task = Task(
            description=f"Beantworte direkt: {question}",
            expected_output="Praezise und faktische Antwort",
            agent=self.simple_responder,
        )
        crew = Crew(agents=[self.simple_responder], tasks=[simple_task])
        return {"type": "simple", "response": crew.kickoff()}

    def _process_complex(self, question: str) -> dict:
        complex_task = Task(
            description=f"Analysiere und beantworte ausfuehrlich: {question}",
            expected_output="Detaillierte Antwort mit Quellen",
            agent=self.complex_responder,
        )
        crew = Crew(agents=[self.complex_responder], tasks=[complex_task])
        return {"type": "complex", "response": crew.kickoff()}

Fehlerbehandlung

DEVELOPERpython
from crewai import Agent, Task, Crew
from typing import Optional
import logging

logger = logging.getLogger(__name__)

class ResilientCrew:
    """Crew mit robuster Fehlerbehandlung."""

    def __init__(self, crew: Crew, max_retries: int = 3):
        self.crew = crew
        self.max_retries = max_retries

    def run_with_retry(self, inputs: dict) -> Optional[str]:
        """Fuehrt die Crew mit automatischem Retry aus."""
        for attempt in range(self.max_retries):
            try:
                result = self.crew.kickoff(inputs=inputs)
                return result

            except Exception as e:
                logger.warning(f"Versuch {attempt + 1} fehlgeschlagen: {e}")

                if attempt == self.max_retries - 1:
                    logger.error(f"Alle Versuche sind fehlgeschlagen")
                    return self._fallback_response(inputs, str(e))

        return None

    def _fallback_response(self, inputs: dict, error: str) -> str:
        """Ausweichantwort im Fehlerfall."""
        return f"""
        Entschuldigung, Ihre Anfrage konnte nicht vollstaendig verarbeitet werden.

        Frage: {inputs.get('question', 'N/A')}
        Fehler: {error}

        Vorschlaege:
        - Formulieren Sie Ihre Frage um
        - Versuchen Sie eine spezifischere Frage
        - Kontaktieren Sie den Support, falls das Problem bestehen bleibt
        """


# Callback fuer Monitoring
def task_callback(task_output):
    """Callback, der nach jeder Aufgabe aufgerufen wird."""
    logger.info(f"Aufgabe abgeschlossen: {task_output.description[:50]}...")
    logger.info(f"Laenge Output: {len(str(task_output.raw))}")


# Crew mit Callbacks
monitored_crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    process=Process.sequential,
    task_callback=task_callback,
    verbose=True,
)

Performance und Optimierung

DEVELOPERpython
from crewai import Crew, Process
import asyncio
from concurrent.futures import ThreadPoolExecutor

class OptimizedCrew:
    """Fuer Performance optimierte Crew."""

    def __init__(self, crew: Crew, cache_enabled: bool = True):
        self.crew = crew
        self.cache = {} if cache_enabled else None

    def run(self, inputs: dict) -> str:
        # Cache pruefen
        cache_key = self._get_cache_key(inputs)
        if self.cache and cache_key in self.cache:
            return self.cache[cache_key]

        # Ausfuehren
        result = self.crew.kickoff(inputs=inputs)

        # In Cache speichern
        if self.cache:
            self.cache[cache_key] = result

        return result

    def _get_cache_key(self, inputs: dict) -> str:
        """Generiert einen Cache-Schluessel."""
        import hashlib
        import json
        content = json.dumps(inputs, sort_keys=True)
        return hashlib.md5(content.encode()).hexdigest()


# Parallele Ausfuehrung mehrerer Crews
async def run_parallel_crews(crews_inputs: list) -> list:
    """Fuehrt mehrere Crews parallel aus."""
    async def run_crew(crew, inputs):
        loop = asyncio.get_event_loop()
        with ThreadPoolExecutor() as executor:
            result = await loop.run_in_executor(
                executor, crew.kickoff, inputs
            )
        return result

    tasks = [run_crew(c, i) for c, i in crews_inputs]
    return await asyncio.gather(*tasks)

Kosten und Metriken

Best Practices

1. Klare und spezifische Rollen

DEVELOPERpython
# GUT - Praezise Rolle mit Kontext
Agent(
    role="E-Commerce-Preispruefer",
    goal="Produktpreise gegen offizielle Kataloge pruefen",
    backstory="E-Commerce-Experte mit 5 Jahren Erfahrung in der Datenverifizierung..."
)

# SCHLECHT - Zu generische Rolle
Agent(
    role="Assistent",
    goal="Helfen",
    backstory="Du hilfst."
)

2. Detaillierte Backstory

DEVELOPERpython
# GUT - Reicher Kontext, der das Verhalten leitet
backstory="""Du bist ein leitender Cybersecurity-Analyst mit 8 Jahren Erfahrung.
Du hast fuer Fortune-500-Unternehmen gearbeitet.
Du bist besonders gut darin, Schwachstellen zu identifizieren und Loesungen vorzuschlagen.
Du kommunizierst klar und handlungsorientiert."""

# SCHLECHT - Zu kurz, gibt keine Orientierung
backstory="Du bist ein Sicherheitsexperte."

3. Tasks mit klaren erwarteten Outputs

DEVELOPERpython
# GUT - Spezifischer und strukturierter Output
Task(
    description="Analysiere die Sicherheitslogs...",
    expected_output="""JSON-Bericht enthaltend:
    - vulnerabilities: Liste der gefundenen Schwachstellen
    - severity: Schweregrad (low/medium/high/critical)
    - recommendations: Korrekturmassnahmen
    - confidence: Vertrauensniveau (0-1)"""
)

# SCHLECHT - Vager Output
Task(
    description="Analysiere die Logs...",
    expected_output="Ein Bericht"
)

Fazit

CrewAI bietet eine intuitive Abstraktion zum Aufbau von Multi-Agent-RAG-Systemen. Der "Team"-Ansatz mit Rollen, Aufgaben und Delegation macht den Code lesbar und wartbar.

Schlüsselpunkte:

• Definieren Sie präzise Rollen mit detaillierten Backstories
• Verwenden Sie benutzerdefinierte Tools für die RAG-Integration
• Implementieren Sie hierarchische Patterns für komplexe Workflows
• Fügen Sie Speicher für kontextuelle Gespräche hinzu

Weiterführende Ressourcen

• LangGraph: RAG-Workflows - Graph-Ansatz
• AutoGen: Microsoft Multi-Agenten - Konversationsansatz
• Function Calling RAG - Aktionen im RAG

Brauchen Sie Agenten-Teams? Ailog nutzt von CrewAI inspirierte Architekturen zur Orchestrierung spezialisierter Agenten. Einfaches Deployment, effiziente Zusammenarbeit.