Agjent kërkimor me Gemini dhe LlamaIndex

LlamaIndex është një strukturë për ndërtimin e agjentëve të njohurive duke përdorur LLM të lidhura me të dhënat tuaja. Ky shembull ju tregon se si të ndërtoni një rrjedhë pune me shumë agjentë për një Agjent Kërkimor. Në LlamaIndex, Workflows janë blloqet ndërtuese të sistemeve agjentë dhe shumë-agjentë.

Ju nevojitet një çelës API Gemini. Nëse nuk e keni tashmë një të tillë, mund ta merrni në Google AI Studio . Së pari, instaloni të gjitha bibliotekat e kërkuara të LlamaIndex. LlamaIndex përdor paketën google-genai në brendësi.

pip install llama-index llama-index-utils-workflow llama-index-llms-google-genai llama-index-tools-google

Konfiguro Gemini në LlamaIndex

Motori i çdo agjenti LlamaIndex është një LLM që merret me arsyetimin dhe përpunimin e tekstit. Ky shembull përdor Gemini 3 Flash. Sigurohuni që ta vendosni çelësin tuaj API si një ndryshore mjedisi .

import os
from llama_index.llms.google_genai import GoogleGenAI

# Set your API key in the environment elsewhere, or with os.environ['GEMINI_API_KEY'] = '...'
assert 'GEMINI_API_KEY' in os.environ

llm = GoogleGenAI(model="gemini-3-flash-preview")

Ndërtoni mjete

Agjentët përdorin mjete për të bashkëvepruar me botën e jashtme, si kërkimi në internet ose ruajtja e informacionit. Mjetet në LlamaIndex mund të jenë funksione të rregullta Python ose të importuara nga ToolSpecs ekzistuese. Gemini vjen me një mjet të integruar për përdorimin e Kërkimit në Google, i cili përdoret këtu.

from google.genai import types

google_search_tool = types.Tool(
    google_search=types.GoogleSearch()
)

llm_with_search = GoogleGenAI(
    model="gemini-3-flash-preview",
    generation_config=types.GenerateContentConfig(tools=[google_search_tool])
)

Tani testoni instancën LLM me një pyetje që kërkon kërkim. Ky udhëzues supozon një cikël ngjarjesh që ekzekutohet (si p.sh. python -m asyncio ose Google Colab).

response = await llm_with_search.acomplete("What's the weather like today in Biarritz?")
print(response)

Agjenti i Kërkimit do të përdorë funksionet e Python si mjete. Ka shumë mënyra se si mund të ndërtoni një sistem për të kryer këtë detyrë. Në këtë shembull, do të përdorni sa vijon:

  1. search_web përdor Gemini me Google Search për të kërkuar në internet informacion mbi temën e dhënë.
  2. record_notes i ruan kërkimet e gjetura në internet shtetit në mënyrë që mjetet e tjera të mund ta përdorin atë.
  3. write_report shkruan raportin duke përdorur informacionin e gjetur nga ResearchAgent
  4. review_report shqyrton raportin dhe jep reagime.

Klasa Context kalon gjendjen midis agjentëve/mjeteve, dhe secili agjent do të ketë qasje në gjendjen aktuale të sistemit.

from llama_index.core.workflow import Context

async def search_web(ctx: Context, query: str) -> str:
    """Useful for searching the web about a specific query or topic"""
    response = await llm_with_search.acomplete(f"""Please research given this query or topic,
    and return the result\n<query_or_topic>{query}</query_or_topic>""")
    return response

async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
    """Useful for recording notes on a given topic."""
    current_state = await ctx.store.get("state")
    if "research_notes" not in current_state:
        current_state["research_notes"] = {}
    current_state["research_notes"][notes_title] = notes
    await ctx.store.set("state", current_state)
    return "Notes recorded."

async def write_report(ctx: Context, report_content: str) -> str:
    """Useful for writing a report on a given topic."""
    current_state = await ctx.store.get("state")
    current_state["report_content"] = report_content
    await ctx.store.set("state", current_state)
    return "Report written."

async def review_report(ctx: Context, review: str) -> str:
    """Useful for reviewing a report and providing feedback."""
    current_state = await ctx.store.get("state")
    current_state["review"] = review
    await ctx.store.set("state", current_state)
    return "Report reviewed."

Ndërtoni një asistent me shumë agjentë

Për të ndërtuar një sistem me shumë agjentë, ju përcaktoni agjentët dhe ndërveprimet e tyre. Sistemi juaj do të ketë tre agjentë:

  1. Një ResearchAgent kërkon në internet për informacion mbi temën e dhënë.
  2. Një WriteAgent shkruan raportin duke përdorur informacionin e gjetur nga ResearchAgent .
  3. Një ReviewAgent shqyrton raportin dhe jep reagime.

Ky shembull përdor klasën AgentWorkflow për të krijuar një sistem me shumë agjentë që do t'i ekzekutojë këta agjentë me radhë. Çdo agjent merr një system_prompt që i tregon se çfarë duhet të bëjë dhe sugjeron se si të punojë me agjentët e tjerë.

Optionally, you can help your multi-agent system by specifying which other agents it can talk to using can_handoff_to (if not, it will try to figure this out on its own).

from llama_index.core.agent.workflow import (
    AgentInput,
    AgentOutput,
    ToolCall,
    ToolCallResult,
    AgentStream,
)
from llama_index.core.agent.workflow import FunctionAgent, ReActAgent

research_agent = FunctionAgent(
    name="ResearchAgent",
    description="Useful for searching the web for information on a given topic and recording notes on the topic.",
    system_prompt=(
        "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. "
        "Once notes are recorded and you are satisfied, you should hand off control to the WriteAgent to write a report on the topic."
    ),
    llm=llm,
    tools=[search_web, record_notes],
    can_handoff_to=["WriteAgent"],
)

write_agent = FunctionAgent(
    name="WriteAgent",
    description="Useful for writing a report on a given topic.",
    system_prompt=(
        "You are the WriteAgent that can write a report on a given topic. "
        "Your report should be in a markdown format. The content should be grounded in the research notes. "
        "Once the report is written, you should get feedback at least once from the ReviewAgent."
    ),
    llm=llm,
    tools=[write_report],
    can_handoff_to=["ReviewAgent", "ResearchAgent"],
)

review_agent = FunctionAgent(
    name="ReviewAgent",
    description="Useful for reviewing a report and providing feedback.",
    system_prompt=(
        "You are the ReviewAgent that can review a report and provide feedback. "
        "Your feedback should either approve the current report or request changes for the WriteAgent to implement."
    ),
    llm=llm,
    tools=[review_report],
    can_handoff_to=["ResearchAgent","WriteAgent"],
)

Agjentët janë përcaktuar, tani mund të krijoni AgentWorkflow dhe ta ekzekutoni atë.

from llama_index.core.agent.workflow import AgentWorkflow

agent_workflow = AgentWorkflow(
    agents=[research_agent, write_agent, review_agent],
    root_agent=research_agent.name,
    initial_state={
        "research_notes": {},
        "report_content": "Not written yet.",
        "review": "Review required.",
    },
)

Gjatë ekzekutimit të rrjedhës së punës, mund të transmetoni ngjarje, thirrje mjetesh dhe përditësime në tastierë.

from llama_index.core.agent.workflow import (
    AgentInput,
    AgentOutput,
    ToolCall,
    ToolCallResult,
    AgentStream,
)

research_topic = """Write me a report on the history of the web.
Briefly describe the history of the world wide web, including
the development of the internet and the development of the web,
including 21st century developments"""

handler = agent_workflow.run(
    user_msg=research_topic
)

current_agent = None
current_tool_calls = ""
async for event in handler.stream_events():
    if (
        hasattr(event, "current_agent_name")
        and event.current_agent_name != current_agent
    ):
        current_agent = event.current_agent_name
        print(f"\n{'='*50}")
        print(f"🤖 Agent: {current_agent}")
        print(f"{'='*50}\n")
    elif isinstance(event, AgentOutput):
        if event.response.content:
            print("📤 Output:", event.response.content)
        if event.tool_calls:
            print(
                "🛠️  Planning to use tools:",
                [call.tool_name for call in event.tool_calls],
            )
    elif isinstance(event, ToolCallResult):
        print(f"🔧 Tool Result ({event.tool_name}):")
        print(f"  Arguments: {event.tool_kwargs}")
        print(f"  Output: {event.tool_output}")
    elif isinstance(event, ToolCall):
        print(f"🔨 Calling Tool: {event.tool_name}")
        print(f"  With arguments: {event.tool_kwargs}")

Pasi të përfundojë rrjedha e punës, mund të printoni rezultatin përfundimtar të raportit, si dhe gjendjen përfundimtare të shqyrtimit nga agjenti i shqyrtimit.

state = await handler.ctx.store.get("state")
print("Report Content:\n", state["report_content"])
print("\n------------\nFinal Review:\n", state["review"])

Shkoni më tej me rrjedhat e punës të personalizuara

AgentWorkflow është një mënyrë e shkëlqyer për të filluar me sistemet me shumë agjentë. Po sikur të keni nevojë për më shumë kontroll? Mund të ndërtoni një rrjedhë pune nga e para. Ja disa arsye pse mund të dëshironi të ndërtoni rrjedhën tuaj të punës:

  • Më shumë kontroll mbi procesin : Ju mund të vendosni rrugën e saktë që ndjekin agjentët tuaj. Kjo përfshin krijimin e sytheve, marrjen e vendimeve në pika të caktuara ose punën paralele të agjentëve në detyra të ndryshme.
  • Përdorni të dhëna komplekse : Shkoni përtej tekstit të thjeshtë. Flukset e punës të personalizuara ju lejojnë të përdorni të dhëna më të strukturuara, si objekte JSON ose klasa të personalizuara, për të dhënat hyrëse dhe dalëse.
  • Punoni me media të ndryshme : Ndërtoni agjentë që mund të kuptojnë dhe përpunojnë jo vetëm tekstin, por edhe imazhet, audion dhe videon.
  • Planifikim më i zgjuar : Mund të hartoni një rrjedhë pune që së pari krijon një plan të detajuar përpara se agjentët të fillojnë punën. Kjo është e dobishme për detyra komplekse që kërkojnë hapa të shumëfishtë.
  • Aktivizoni vetë-korrigjimin : Krijoni agjentë që mund të rishikojnë punën e tyre. Nëse rezultati nuk është mjaftueshëm i mirë, agjenti mund të provojë përsëri, duke krijuar një cikël përmirësimi derisa rezultati të jetë perfekt.

Për të mësuar më shumë rreth Flukseve të Punës LlamaIndex, shihni Dokumentacionin e Flukseve të Punës LlamaIndex .