Agjent kërkimor me Gemini 2.5 Pro dhe LlamaIndex

LlamaIndex është një kornizë 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ë fluks pune me shumë agjentë për një agjent kërkimor. Në LlamaIndex, Workflows janë blloqet ndërtuese të sistemeve të agjentëve ose shumë agjentëve.

Ju duhet 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 LlamaIndex. LlamaIndex përdor paketën google-genai nën kapak.

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

Konfiguro Gemini 2.5 Pro në LlamaIndex

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

from llama_index.llms.google_genai import GoogleGenAI

llm = GoogleGenAI(model="gemini-2.5-pro")

Ndërtoni mjete

Agjentët përdorin mjete për të bashkëvepruar me botën e jashtme, si kërkimi në ueb ose ruajtja e informacionit. Mjetet në LlamaIndex mund të jenë funksione të rregullta Python, ose të importuara nga ToolSpecs para-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-2.5-pro",
    generation_config=types.GenerateContentConfig(tools=[google_search_tool])
)

Tani testoni shembullin LLM me një pyetje që kërkon kërkim:

response = llm_with_search.complete("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 për të ndërtuar një sistem për të kryer këtë detyrë. Në këtë shembull, ju do të përdorni sa vijon:

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

Klasa Context kalon gjendjen ndërmjet agjentëve/veglave dhe çdo agjent do të ketë akses 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ë ueb 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 komente.

Ky shembull përdor klasën AgentWorkflow për të krijuar një sistem me shumë agjentë që do t'i ekzekutojë këta agjentë në rregull. Ç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ë.

Opsionale, ju mund të ndihmoni sistemin tuaj me shumë agjentë duke specifikuar se me cilët agjentë të tjerë mund të flasë duke përdorur can_handoff_to (nëse jo, ai do të përpiqet ta kuptojë vetë).

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}")

Pas përfundimit të rrjedhës së punës, mund të printoni rezultatin përfundimtar të raportit, si dhe gjendjen përfundimtare të shqyrtimit nga agjenti i rishikimit.

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 flukset e punës me porosi

AgentWorkflow është një mënyrë e shkëlqyer për të filluar me sistemet me shumë agjentë. Por çfarë nëse keni nevojë për më shumë kontroll? Ju mund të ndërtoni një rrjedhë pune nga e para. Këtu janë disa arsye pse mund të dëshironi të krijoni rrjedhën tuaj të punës:

  • Më shumë kontroll mbi procesin : Ju mund të vendosni rrugën e saktë që do të marrin agjentët tuaj. Kjo përfshin krijimin e sytheve, marrjen e vendimeve në pika të caktuara ose punën e agjentëve paralelisht në detyra të ndryshme.
  • Përdorni të dhëna komplekse : Shkoni përtej tekstit të thjeshtë. Rrjedhat e personalizuara të punës ju lejojnë të përdorni të dhëna më të strukturuara, si objekte JSON ose klasa të personalizuara, për hyrjet dhe daljet tuaja.
  • 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.
  • Planifikimi më i zgjuar : Mund të hartoni një rrjedhë pune që së pari krijon një plan të detajuar përpara se agjentët të fillojnë të punojnë. Kjo është e dobishme për detyra komplekse që kërkojnë hapa të shumtë.
  • Aktivizo vetëkorrigjimin : Krijo 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ë lak përmirësimi derisa rezultati të jetë i përsosur.

Për të mësuar më shumë rreth flukseve të punës LlamaIndex, shihni Dokumentacionin e flukseve të punës LlamaIndex .