LlamaIndex Query Pipeline-Agent erstellen

Mit der Agent Runtime können Sie KI-Agenten mit der LlamaIndex-Vorlage für Abfragepipelines entwickeln und bereitstellen. Mit der Klasse LlamaIndexQueryPipelineAgent im Agent Platform SDK können Sie Agenten für Retrieval-Augmented Generation (RAG) erstellen.

In diesem Dokument wird beschrieben, wie Sie einen LlamaIndex Query Pipeline-Agenten entwickeln, einschließlich der Definition des Modells, der Einrichtung eines Retrievers und der Synthese von Antworten.

Weitere Informationen zum Verwalten Ihrer bereitgestellten Agenten finden Sie unter Bereitgestellte Agenten verwalten.

Hinweis

Richten Sie Ihre Umgebung ein, indem Sie die Schritte unter Umgebung einrichten ausführen.

Modell definieren und konfigurieren

Definieren und konfigurieren Sie ein Modell, das Ihr LlamaIndex Query Pipeline-Agent verwenden soll:

  1. Geben Sie das gewünschte Modell an:

    model = "gemini-3.5-flash"

  2. Optional: Geben Sie Modellparameter an:

    model_kwargs = {
    # vertexai_config (dict): By providing the region and project_id parameters,
    # you can enable model usage through Agent Platform.
    "vertexai_config": {
        "project": "PROJECT_ID",
        "location": "LOCATION"
    },
    # temperature (float): The sampling temperature controls the degree of
    # randomness in token selection.
    "temperature": 0.28,
    # context_window (int): The context window of the model.
    # If not provided, the default context window is 200000.
    "context_window": 200000,
    # max_tokens (int): Token limit determines the maximum
    # amount of text output from one prompt. If not provided,
    # the default max_tokens is 256.
    "max_tokens": 256,
}

  3. Erstellen Sie einen LlamaIndexQueryPipelineAgent mit den folgenden Modellkonfigurationen:

    from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

  4. Wenn Sie in einer interaktiven Umgebung (z. B. im Terminal oder in einem Colab-Notebook) arbeiten, können Sie den Agenten abfragen:

    response = agent.query(input="What is Paul Graham's life in college?")

print(response)

    Sie sollten eine Antwort ähnlich der folgenden erhalten:

    {'message': {'role': 'assistant',
  'additional_kwargs': {},
  'blocks': [{'block_type': 'text',
    'text': "Unfortunately, there's not a lot of publicly available information about Paul Graham's personal life in college. ..."}]},
  'raw': {'content': {'parts': [{'video_metadata': None,
      'thought': None,
      'code_execution_result': None,
      'executable_code': None,
      'file_data': None,
      'function_call': None,
      'function_response': None,
      'inline_data': None,
      'text': "Unfortunately, there's not a lot of publicly available information about Paul Graham's personal life in college. ..."}],
    'role': 'model'},
    'citation_metadata': None,
    'finish_message': None,
    'token_count': None,
    'avg_logprobs': -0.1468650027438327,
    'finish_reason': 'STOP',
    'grounding_metadata': None,
    'index': None,
    'logprobs_result': None,
    'safety_ratings': [{'blocked': None,
      'category': 'HARM_CATEGORY_HATE_SPEECH',
      'probability': 'NEGLIGIBLE',
      'probability_score': 0.022949219,
      'severity': 'HARM_SEVERITY_NEGLIGIBLE',
      'severity_score': 0.014038086},
    {'blocked': None,
      'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',
      'probability': 'NEGLIGIBLE',
      'probability_score': 0.056640625,
      'severity': 'HARM_SEVERITY_NEGLIGIBLE',
      'severity_score': 0.029296875},
    {'blocked': None,
      'category': 'HARM_CATEGORY_HARASSMENT',
      'probability': 'NEGLIGIBLE',
      'probability_score': 0.071777344,
      'severity': 'HARM_SEVERITY_NEGLIGIBLE',
      'severity_score': 0.024047852},
    {'blocked': None,
      'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
      'probability': 'NEGLIGIBLE',
      'probability_score': 0.103515625,
      'severity': 'HARM_SEVERITY_NEGLIGIBLE',
      'severity_score': 0.05102539}],
    'usage_metadata': {'cached_content_token_count': None,
    'candidates_token_count': 222,
    'prompt_token_count': 10,
    'total_token_count': 232}},
  'delta': None,
  'logprobs': None,
  'additional_kwargs': {}}

Optional: Modell anpassen

Die Vorlage LlamaIndexQueryPipelineAgent verwendet standardmäßig Google GenAI, um Zugriff auf alle in Google Cloudverfügbaren Foundation Models zu gewähren. Wenn Sie ein Modell verwenden möchten, das nicht über Google GenAI verfügbar ist, definieren Sie model_builder= so:

from typing import Optional

def model_builder(
    *,
    model_name: str,                      # Required. The name of the model
    model_kwargs: Optional[dict] = None,  # Optional. The model keyword arguments.
    **kwargs,                             # Optional. The remaining keyword arguments to be ignored.
):

Eine Liste der in LlamaIndexQueryPipeline unterstützten Chatmodelle und ihrer Funktionen finden Sie unter Verfügbare LLM-Integrationen. Jedes Chatmodell verwendet einen eigenen Satz unterstützter Werte für model= und model_kwargs=.

Google GenAI

Google GenAI wird standardmäßig installiert, wenn Sie Ihre Umgebung einrichten, und automatisch in LlamaIndexQueryPipelineAgent verwendet, wenn Sie model_builder weglassen.

from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

Anthropic

  1. Folgen Sie der Anthropic-Dokumentation, um ein Konto einzurichten und das llama-index-llms-anthropic-Paket zu installieren.

  2. Definieren Sie model_builder, um das Modell Anthropic zurückzugeben:

    def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
    from llama_index.llms.anthropic import Anthropic

    return Anthropic(model=model_name, **model_kwargs)

  3. Verwenden Sie das Anthropic-Modell in LlamaIndexQueryPipelineAgent:

    from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model="claude-3-opus-20240229",           # Required.
    model_builder=model_builder,              # Required.
    model_kwargs={
        "api_key": "ANTHROPIC_API_KEY",    # Required.
        "temperature": 0.28,                  # Optional.
    },
)

OpenAILike

Sie können OpenAILike mit der ChatCompletions API von Gemini verwenden.

  1. Folgen Sie der OpenAILike-Dokumentation, um das Paket zu installieren:

    pip install llama-index-llms-openai-like

  2. Definieren Sie einen model_builder, der das OpenAILike-Modell zurückgibt:

    def model_builder(
    *,
    model_name: str,
    model_kwargs = None,
    project: str,   # Specified via vertexai.init
    location: str,  # Specified via vertexai.init
    **kwargs,
):
    import google.auth
    from llama_index.llms.openai_like import OpenAILike

    # Note: the credential lives for 1 hour by default.
    # After expiration, it must be refreshed.
    creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
    auth_req = google.auth.transport.requests.Request()
    creds.refresh(auth_req)

    if model_kwargs is None:
        model_kwargs = {}

    endpoint = f"https://{location}-aiplatform.googleapis.com"
    api_base = f'{endpoint}/v1beta1/projects/{project}/locations/{location}/endpoints/openapi'

    return OpenAILike(
        model=model_name,
        api_base=api_base,
        api_key=creds.token,
        **model_kwargs,
    )

  3. Verwenden Sie das Modell in LlamaIndexQueryPipelineAgent:

    from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model="google/gemini-3.5-flash",  # Or "meta/llama3-405b-instruct-maas"
    model_builder=model_builder,        # Required.
    model_kwargs={
        "temperature": 0,               # Optional.
        "max_retries": 2,               # Optional.
    },
)

Retriever definieren und verwenden

Nachdem Sie Ihr Modell definiert haben, definieren Sie den Retriever, den Ihr Modell für die Logik verwendet. Ein Retriever kann auf Indexen basieren, aber auch umfassend definiert werden. Sie sollten Ihren Retriever lokal testen.

  1. Definieren Sie einen Retriever, der relevante Dokumente und Ähnlichkeitswerte zurückgibt:

    def retriever_builder(model, retriever_kwargs=None):
    import os
    import requests
    from llama_index.core import (
        StorageContext,
        VectorStoreIndex,
        load_index_from_storage,
    )
    from llama_index.core import SimpleDirectoryReader
    from llama_index.embeddings.vertex import VertexTextEmbedding
    import google.auth

    credentials, _ = google.auth.default()
    embed_model = VertexTextEmbedding(
        model_name="text-embedding-005", project="PROJECT_ID", credentials=credentials
    )

    data_dir = "data/paul_graham"
    essay_file = os.path.join(data_dir, "paul_graham_essay.txt")
    storage_dir = "storage"

    # --- Simple Download (if needed) ---
    if not os.path.exists(essay_file):
        os.makedirs(data_dir, exist_ok=True)  # Make sure the directory exists
        essay_url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
        try:
            response = requests.get(essay_url)
            response.raise_for_status()  # Check for download errors
            with open(essay_file, "wb") as f:
                f.write(response.content)
            print("Essay downloaded.")
        except requests.exceptions.RequestException as e:
            print(f"Download failed: {e}")

    # --- Build/Load Index ---
    if not os.path.exists(storage_dir):
        print("Creating new index...")
        # --- Load Data ---
        reader = SimpleDirectoryReader(data_dir)
        docs = reader.load_data()

        index = VectorStoreIndex.from_documents(docs, model=model, embed_model=embed_model)
        index.storage_context.persist(persist_dir=storage_dir)
    else:
        print("Loading existing index...")
        storage_context = StorageContext.from_defaults(persist_dir=storage_dir)
        index = load_index_from_storage(storage_context, embed_model=embed_model)

    return index.as_retriever()

  2. Testen Sie den Retriever:

    from llama_index.llms.google_genai import GoogleGenAI

model = GoogleGenAI(
    model=model,
    **model_kwargs
)
retriever = retriever_builder(model)
retrieved_response = retriever.retrieve("What is Paul Graham's life in College?")

    Die abgerufene Antwort sollte in etwa so aussehen:

    [
  NodeWithScore(
    node=TextNode(
      id_='692a5d5c-cd56-4ed0-8e29-ecadf6eb9933',
      embedding=None,
      metadata={'file_path': '/content/data/paul_graham/paul_graham_essay.txt', 'file_name': 'paul_graham_essay.txt', 'file_type': 'text/plain', 'file_size': 75042, 'creation_date': '2025-03-24', 'last_modified_date': '2025-03-24'},
      excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'],
      excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'],
      relationships={
        <NodeRelationship.SOURCE: '1'>: RelatedNodeInfo(node_id='3e1c4d73-1e1d-4e83-bd16-2dae24abb231', node_type='4', metadata={'file_path': '/content/data/paul_graham/paul_graham_essay.txt', 'file_name': 'paul_graham_essay.txt', 'file_type': 'text/plain', 'file_size': 75042, 'creation_date': '2025-03-24', 'last_modified_date': '2025-03-24'}, hash='0c3c3f46cac874b495d944dfc4b920f6b68817dbbb1699ecc955d1fafb2bf87b'), <NodeRelationship.PREVIOUS: '2'>: RelatedNodeInfo(node_id='782c5787-8753-4f65-85ed-c2833ea6d4d8', node_type='1', metadata={'file_path': '/content/data/paul_graham/paul_graham_essay.txt', 'file_name': 'paul_graham_essay.txt', 'file_type': 'text/plain', 'file_size': 75042, 'creation_date': '2025-03-24', 'last_modified_date': '2025-03-24'}, hash='b8e6463833887a8a2b13f1b5a623672819faedc1b725d9565ba003223628db0e'), <NodeRelationship.NEXT: '3'>: RelatedNodeInfo(node_id='f7d2cb7e-fa0c-40bf-b8e7-b888e36b87f9', node_type='1', metadata={}, hash='db7cc1a67fa3afd1e5f24c8c61583781ce6a00c444da8f25a5374468c17b7de0')
      },
      metadata_template='{key}: {value}',
      metadata_separator='\n',
      text='So I looked around to see what I could salvage from the wreckage of my plans, and there was Lisp...',
      mimetype='text/plain',
      start_char_idx=7166,
      end_char_idx=11549,
      metadata_separator='\n',
      text_template='{metadata_str}\n\n{content}'
    ),
    score=0.7403571819090398
  )
]

  3. Wenn Sie den Retriever in LlamaIndexQueryPipelineAgent verwenden möchten, fügen Sie ihn unter dem Argument retriever_builder= hinzu:

    from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model=model,                          # Required.
    model_kwargs=model_kwargs,            # Optional.
    retriever_builder=retriever_builder,  # Optional.
)

  4. Testen Sie den Agenten lokal, indem Sie Testabfragen ausführen:

    response = agent.query(
    input="What is Paul Graham's life in College?"
)

    Die Antwort ist eine JSON-serialisierbare Liste von Knoten mit Bewertungen.

    [{'node': {'id_': '692a5d5c-cd56-4ed0-8e29-ecadf6eb9933',
  'embedding': None,
  'metadata': {'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
    'file_name': 'paul_graham_essay.txt',
    'file_type': 'text/plain',
    'file_size': 75042,
    'creation_date': '2025-03-12',
    'last_modified_date': '2025-03-12'},
  'excluded_embed_metadata_keys': ['file_name',
    'file_type',
    'file_size',
    'creation_date',
    'last_modified_date',
    'last_accessed_date'],
  'excluded_llm_metadata_keys': ['file_name',
    'file_type',
    'file_size',
    'creation_date',
    'last_modified_date',
    'last_accessed_date'],
  'relationships': {'1': {'node_id': '07ee9574-04c8-46c7-b023-b22ba9558a1f',
    'node_type': '1',
    'metadata': {},
    'hash': '44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a',
    'class_name': 'RelatedNodeInfo'},
    '2': {'node_id': 'ac7e54aa-6fff-40b5-a15e-89c5eb234936',
    'node_type': '1',
    'metadata': {'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
      'file_name': 'paul_graham_essay.txt',
      'file_type': 'text/plain',
      'file_size': 75042,
      'creation_date': '2025-03-12',
      'last_modified_date': '2025-03-12'},
    'hash': '755327a01efe7104db771e4e6f9683417884ea6895d878da882d2b21a6b66442',
    'class_name': 'RelatedNodeInfo'},
    '3': {'node_id': '3a04be27-ac46-4acd-a8c6-031689508982',
    'node_type': '1',
    'metadata': {},
    'hash': 'db7cc1a67fa3afd1e5f24c8c61583781ce6a00c444da8f25a5374468c17b7de0',
    'class_name': 'RelatedNodeInfo'}},
  'metadata_template': '{key}: {value}',
  'metadata_separator': '\n',
  'text': 'So I looked around to see what I could salvage from the wreckage of my plans, and there was Lisp...',
  'mimetype': 'text/plain',
  'start_char_idx': 7164,
  'end_char_idx': 11547,
  'metadata_separator': '\n',
  'text_template': '{metadata_str}\n\n{content}',
  'class_name': 'TextNode'},
  'score': 0.25325886336265013,
  'class_name': 'NodeWithScore'}
]

Antwortsynthesizer definieren und verwenden

Nachdem Sie Ihr Modell und Ihren Retriever definiert haben, definieren Sie den Antwortsynthesizer, der anhand einer Nutzeranfrage und einer bestimmten Gruppe von Textblöcken eine Antwort von einem LLM generiert. Sie können den Standard-get_response_synthesizer verwenden oder den Antwortmodus konfigurieren.

  1. Definieren Sie einen Antwortsynthesizer, der die Antwort zurückgibt:

    def response_synthesizer_builder(model, response_synthesizer_kwargs=None):
    from llama_index.core.response_synthesizers import SimpleSummarize

    return SimpleSummarize(llm=model)

  2. Die Funktion testen:

    response_synthesizer = response_synthesizer_builder(model=model)
response = response_synthesizer.get_response(
    "What is Paul Graham's life in College?",
    [node.model_dump_json() for node in retrieved_response],
)

    Die Antwort sollte in etwa so aussehen:

    "While in a PhD program for computer science, he took art classes and worked on a book about Lisp hacking. He applied to art schools, got accepted to RISD, and later got an invitation to take the entrance exam at the Accademia di Belli Arti in Florence. He was accepted to both. He attended the Accademia, but was disappointed by the lack of instruction."

  3. Wenn Sie den Antwortsynthesizer in LlamaIndexQueryPipelineAgent verwenden möchten, fügen Sie ihn unter dem Argument response_synthesizer_builder= hinzu:

    from vertexai.preview import reasoning_engines

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model=model,                                                    # Required.
    model_kwargs=model_kwargs,                                      # Optional.
    retriever_builder=retriever_builder,                            # Optional.
    response_synthesizer_builder=response_synthesizer_builder,      # Optional.
)

  4. Testen Sie die gesamte RAG-Abfragepipeline lokal, indem Sie Testabfragen ausführen:

    response = agent.query(
    input="What is Paul Graham's life in College?"
)

    Die Antwort ist ein Wörterbuch, das in etwa so aussieht:

    {
  'response': "While in college, he was drawn to McCarthy's 1960 Lisp, although he didn't fully grasp the reasons for his interest at the time. He also had a brief encounter with surplus Xerox Dandelions in the computer lab but found them too slow for his liking. \n",
  'source_nodes': [
    '{"node":{"id_":"95889c30-53c7-43d0-bf91-930dbb23bde6"...,"score":0.7077213268404997,"class_name":"NodeWithScore"}'
  ],
  'metadata': {
    '95889c30-53c7-43d0-bf91-930dbb23bde6': {
      'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
      'file_name': 'paul_graham_essay.txt',
      'file_type': 'text/plain',
      'file_size': 75042,
      'creation_date': '2025-03-25',
      'last_modified_date': '2025-03-25'
    }
  }
}

Optional: Prompt-Vorlage anpassen

Prompt-Vorlagen übersetzen Nutzereingaben in Modellanweisungen und steuern die Antworten, um kontextrelevante und kohärente Ausgaben zu erhalten. Weitere Informationen finden Sie unter Prompts.

Die Standard-Prompt-Vorlage ist sequenziell in die folgenden Abschnitte unterteilt:

Bereich Beschreibung
Optional: Systemanweisung Anweisungen für den Agenten, die für alle Abfragen gelten.
Nutzereingabe Die Anfrage des Nutzers, auf die der KI-Agent antworten soll.

Die Standard-Prompt-Vorlage wird generiert, wenn Sie den KI-Agenten erstellen, ohne eine eigene Prompt-Vorlage anzugeben. Sie sieht so aus:

from llama_index.core import prompts
from llama_index.core.base.llms import types

message_templates = [
  types.ChatMessage(role=types.MessageRole.SYSTEM, content=system_instruction),
  types.ChatMessage(role=types.MessageRole.USER, content="{input}"),
]
prompts.ChatPromptTemplate(message_templates=message_templates)

Sie können die vollständige Prompt-Vorlage verwenden, wenn Sie den Agenten im folgenden Beispiel instanziieren:

  from vertexai.preview import reasoning_engines

  system_instruction = "I help to find what is Paul Graham's life in College"

  agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
      model=model,
      system_instruction=system_instruction,
  )

Sie können die Standard-Prompt-Vorlage durch Ihre eigene Prompt-Vorlage überschreiben und diese beim Erstellen des KI-Agenten verwenden:

prompt_str = "Please answer {question} about {name}"
prompt_tmpl = PromptTemplate(prompt_str)

from vertexai.preview import reasoning_engines
agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
    model = model,
    prompt = prompt_tmpl,
)

agent.query(
    input={
        "name": "Paul Graham",
        "question": "What is the life in college?",
    }
)

Optional: Orchestrierung anpassen

Alle LlamaIndexQueryPipeline-Komponenten implementieren die Query Component-Schnittstelle, die Eingabe- und Ausgabeschemas für die Orchestrierung bereitstellt. Für die Klasse LlamaIndexQueryPipelineAgent muss ein ausführbares Programm erstellt werden, damit sie auf Abfragen reagieren kann. Standardmäßig erstellt LlamaIndexQueryPipelineAgent eine sequenzielle Kette oder einen gerichteten azyklischen Graphen (DAG) mit Query Pipeline.

Sie können die Orchestrierung anpassen, wenn Sie Folgendes tun möchten:

  • Implementieren Sie einen Agenten, der die RAG-Pipeline erweitert (z. B. durch Erweitern eines vorhandenen Prompt-, Modell-, Retriever- oder Response Synthesizer-Moduls auf Query Engine, Query Transformer, Output Parsers, Postprocessor/Rerankers oder Custom Query Component).

  • Fordern Sie den Agenten mit ReAct auf, Tools auszuführen und jeden Schritt mit Kommentaren zu versehen, warum er diesen Schritt ausgeführt hat. Überschreiben Sie dazu beim Erstellen von LlamaIndexQueryPipelineAgent das ausführbare Standardprogramm, indem Sie das Argument runnable_builder= angeben:

    from typing import Optional
from llama_index.core.llms import function_calling

def runnable_builder(
    model: function_calling.FunctionCallingLLM,
    *,
    system_instruction: Optional[str] = None,
    prompt: Optional[query.QUERY_COMPONENT_TYPE] = None,
    retriever: Optional[query.QUERY_COMPONENT_TYPE] = None,
    response_synthesizer: Optional[query.QUERY_COMPONENT_TYPE] = None,
    runnable_kwargs: Optional[Mapping[str, Any]] = None,
):

    Wobei:

    • model entspricht dem Chatmodell, das von model_builder zurückgegeben wird (siehe Modell definieren und konfigurieren).
    • retriever und retriever_kwargs entsprechen dem Retriever und den zu verwendenden Konfigurationen (siehe Retriever definieren).
    • response_synthesizer und response_synthesizer_kwargs entsprechen dem Antwortsynthesizer und den zu verwendenden Konfigurationen (siehe Antwortsynthesizer definieren).
    • system_instruction und prompt entsprechen der Prompt-Konfiguration (siehe Prompt-Vorlage anpassen).
    • agent_executor_kwargs und runnable_kwargs sind die Keyword-Argumente, mit denen Sie das Runnable anpassen können.

Sie können die Orchestrierungslogik mit einer benutzerdefinierten Pipeline oder ReAct anpassen:

Benutzerdefinierte Pipeline

Wenn Sie dem Agenten ein zusätzliches Modul (z. B. einen Postprozessor) zur Verfügung stellen möchten, überschreiben Sie die runnable_builder für LlamaIndexQueryPipelineAgent.

  1. Postprozessor definieren:

    def post_processor_builder():
  from llama_index.core.postprocessor import SimilarityPostprocessor

  # similarity postprocessor: filter nodes below 0.7 similarity score
  return SimilarityPostprocessor(similarity_cutoff=0.7)

def runnable_with_postprocessor_builder(
    model, runnable_kwargs, **kwargs
):
  from llama_index.core.query_pipeline import QueryPipeline

  pipeline = QueryPipeline(**runnable_kwargs)
  pipeline_modules = {
      "retriever": retriever_builder(model),
      "postprocessor": post_processor_builder(),
  }
  pipeline.add_modules(pipeline_modules)
  pipeline.add_link("retriever", "postprocessor")

  return pipeline

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
  model=model,
  runnable_builder=runnable_with_postprocessor_builder,
)

  2. Senden Sie den folgenden Prompt an den KI-Agenten:

    result = agent.query(input="What is Paul Graham's life in College?")

    Die Ausgabe sollte in etwa so aussehen:

    [
  {
    'node': {'id_': 'bb7d2942-213d-4fb3-a7cb-1a664642a7ff',
    'embedding': None,
    'metadata': {
      'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
      'file_name': 'paul_graham_essay.txt',
      'file_type': 'text/plain',
      'file_size': 75042,
      'creation_date': '2025-03-25',
      'last_modified_date': '2025-03-25'
    },
    'excluded_embed_metadata_keys': [
      'file_name',
      'file_type',
      'file_size',
      'creation_date',
      'last_modified_date',
      'last_accessed_date'
    ],
    'excluded_llm_metadata_keys': [
      'file_name',
      'file_type',
      'file_size',
      'creation_date',
      'last_modified_date',
      'last_accessed_date'
    ],
    'relationships': {'1': {'node_id': 'c508cee5-5ef2-4fdf-a33d-0427dcb78b5c',
      'node_type': '4',
      'metadata': {'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
        'file_name': 'paul_graham_essay.txt',
        'file_type': 'text/plain',
        'file_size': 75042,
        'creation_date': '2025-03-25',
        'last_modified_date': '2025-03-25'},
      'hash': '0c3c3f46cac874b495d944dfc4b920f6b68817dbbb1699ecc955d1fafb2bf87b',
      'class_name': 'RelatedNodeInfo'},
      '2': {'node_id': '97a84b41-62bf-4959-acae-cfd4bdfbd4d9',
      'node_type': '1',
      'metadata': {'file_path': '/content/data/paul_graham/paul_graham_essay.txt',
        'file_name': 'paul_graham_essay.txt',
        'file_type': 'text/plain',
        'file_size': 75042,
        'creation_date': '2025-03-25',
        'last_modified_date': '2025-03-25'},
      'hash': 'a7dd352be97e47e8e553ceda3d2d2c9e9d5c54adb298063c94da06167938d583',
      'class_name': 'RelatedNodeInfo'},
      '3': {'node_id': 'b984eea1-f0bc-4880-812e-3f49f1e304b8',
      'node_type': '1',
      'metadata': {},
      'hash': 'db7cc1a67fa3afd1e5f24c8c61583781ce6a00c444da8f25a5374468c17b7de0',
      'class_name': 'RelatedNodeInfo'}},
    'metadata_template': '{key}: {value}',
    'metadata_separator': '\n',
    'text': 'So I looked around to see what I could salvage from the wreckage of my plans, and there was Lisp...',
    'mimetype': 'text/plain',
    'start_char_idx': 7166,
    'end_char_idx': 11549,
    'metadata_separator': '\n',
    'text_template': '{metadata_str}\n\n{content}',
    'class_name': 'TextNode'},
    'score': 0.7403571819090398,
    'class_name': 'NodeWithScore'
  },
  {
    'node': {'id_': 'b984eea1-f0bc-4880-812e-3f49f1e304b8...'}
    'score': 0.7297395567513889,
    'class_name': 'NodeWithScore'
  }
]

ReAct-Agent

Wenn Sie das Tool-Aufrufverhalten mit Ihrem eigenen ReAct-Agenten bereitstellen möchten, überschreiben Sie runnable_builder für LlamaIndexQueryPipelineAgent.

  1. Definieren Sie eine Beispielfunktion, die einen Wechselkurs zurückgibt:

    def get_exchange_rate(
  currency_from: str = "USD",
  currency_to: str = "EUR",
  currency_date: str = "latest",
):
  """Retrieves the exchange rate between two currencies on a specified date.

  Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
  exchange rate data.

  Args:
      currency_from: The base currency (3-letter currency code).
          Defaults to "USD" (US Dollar).
      currency_to: The target currency (3-letter currency code).
          Defaults to "EUR" (Euro).
      currency_date: The date for which to retrieve the exchange rate.
          Defaults to "latest" for the most recent exchange rate data.
          Can be specified in YYYY-MM-DD format for historical rates.

  Returns:
      dict: A dictionary containing the exchange rate information.
          Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
              "rates": {"EUR": 0.95534}}
  """
  import requests
  response = requests.get(
      f"https://api.frankfurter.app/{currency_date}",
      params={"from": currency_from, "to": currency_to},
  )
  return response.json()

  2. Erstellen Sie einen benutzerdefinierten ReAct-Agenten mit Tools:

    def runnable_with_tools_builder(model, runnable_kwargs=None, **kwargs):
  from llama_index.core.query_pipeline import QueryPipeline
  from llama_index.core.tools import FunctionTool
  from llama_index.core.agent import ReActAgent

  llama_index_tools = []
  for tool in runnable_kwargs.get("tools"):
      llama_index_tools.append(FunctionTool.from_defaults(tool))
  agent = ReActAgent.from_tools(llama_index_tools, llm=model, verbose=True)
  return QueryPipeline(modules = {"agent": agent})

agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
  model="gemini-3.5-flash",
  runnable_kwargs={"tools": [get_exchange_rate]},
  runnable_builder=runnable_with_tools_builder,
)

  3. Senden Sie den folgenden Prompt an den KI-Agenten:

    result = agent.query(input="What is the exchange rate between US and EURO today?")

    Die Ausgabe sollte so aussehen:

    {
  'response': 'The exchange rate between US and EURO today, 2025-03-19, is 1 USD to 0.91768 EUR.',
  'source_nodes': [],
  'metadata': None
}

Nächste Schritte

Anleitung

Hier erfahren Sie, wie Sie einen Agenten auf der Agent Platform Runtime auf fünf verschiedene Arten bereitstellen können, je nach Ihren Entwicklungsanforderungen.

Anleitung

LlamaIndex-Query-Pipeline-Agenten mit der Agent Platform Runtime verwenden

Anleitung

Einfachen Agenten erstellen und bereitstellen und mit dem Gen AI Evaluation Service bewerten

Fehlerbehebung

Hier erfahren Sie, wie Sie häufige Fehler beim Erstellen benutzerdefinierter KI-Agenten beheben.

Ressource

Hier finden Sie Ressourcen und Support für die Google Agent Platform.