Agentic Workflows

in LlamaIndex

2025-05-12 AI Tinkerers Tel Aviv Hackathon

What are we talking about?

  • What is LlamaIndex
  • What is an gent?
  • Why build agents?
  • What is RAG?
  • Why agents need RAG
  • Agent Patterns in LlamaIndex
    • Chaining
    • Routing
    • Parallelization
    • Orchestrator-Workers
    • Evaluator-Optimizer
  • How to build agents in LlamaIndex

What is LlamaIndex?

Python: docs.llamaindex.ai

TypeScript: ts.llamaindex.ai

LlamaParse

World's best parser of complex documents

Free for 10000 pages/month!

cloud.llamaindex.ai

LlamaCloud

Turn-key RAG API for Enterprises

Available as SaaS or private cloud deployment

Sign up at cloud.llamaindex.ai

LlamaHub

llamahub.ai

Why LlamaIndex?

  • Build faster
  • Skip the boilerplate
  • Avoid early pitfalls
  • Get best practices for free
  • Go from prototype to production

What can you build in LlamaIndex?

  • Lots of stuff! Especially...
  • AI agents
  • RAG

What is an agent?

Semi-autonomous software

that uses tools to accomplish a goal

Agentic programming is a new paradigm

When does an agent make sense?

When your data is messy, which is most of the time

LLMs are good at turning lots of text into less text

LLMs work well under the hood

You don't have to build a chatbot

LLMs need data

The solution is RAG

RAG = infinite context

Agents need RAG

and RAG needs agents

Building Effective Agents

anthropic.com/research/building-effective-agents

  • Chaining
  • Routing
  • Parallelization
  • Orchestrator-Workers
  • Evaluator-Optimizer

Chaining

Workflows

class MyWorkflow(Workflow):
    @step
    async def step_one(self, ev: StartEvent) -> FirstEvent:
        print(ev.first_input)
        return FirstEvent(first_output="First step complete.")

    @step
    async def step_two(self, ev: FirstEvent) -> SecondEvent:
        print(ev.first_output)
        return SecondEvent(second_output="Second step complete.")

    @step
    async def step_three(self, ev: SecondEvent) -> StopEvent:
        print(ev.second_output)
        return StopEvent(result="Workflow complete.")

Workflow visualization

Routing

Branching

Parallelization

Sectioning

Parallelization: flavor 1

Voting

Parallelization: flavor 2

Concurrency

Orchestrator-Workers

Concurrency

(again)

Evaluator-Optimizer

aka Self-reflection

Looping

Arbitrary complexity

Tool use

def multiply(a: int, b: int) -> int:
    """Multiply two integers and return the result."""
    return a * b

multiply_tool = FunctionTool.from_defaults(fn=multiply)

FunctionAgent

agent = FunctionAgent.from_tools_or_functions(
    [multiply_tool],
    llm=llm,
    system_prompt="You are a helpful agent"
)
response = agent.chat("What is 3 times 4?")

Multi-agent systems

AgentWorkflow

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"],
)

Multi-agent system

as a one-liner

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

Full AgentWorkflow and Workflows tutorial

bit.ly/deep-research-notebook

What's next?

bit.ly/llamaindex-discord

Thanks!

Follow me on BlueSky:

🦋 @seldo.com

bit.ly/ai-tinkerers