LlamaIndex

The base layer is Workflows: steps are async functions that receive and emit typed events, and a run is the event flow between them. Agents (FunctionAgent, ReActAgent) and AgentWorkflow are pre-built workflows that handle tool calling and streaming.

For multiple agents, AgentWorkflow takes a list of agents and a root agent. The active agent calls tools and may hand control to another agent listed in its can_handoff_to, until one returns a final answer or hands back to the user. The docs also describe an orchestrator agent that calls sub-agents as tools, and a custom planner written by hand.

Run state lives in a Context object that can carry values between runs and be serialized to JSON or pickle for later resumption. Conversation memory is a Memory object: recent messages up to a token limit, with older messages flushed into optional long-term memory blocks. Retrieval over documents (indexes, retrievers, query engines) is the framework's original core and can be exposed to agents as tools.

A tool can pause for a person by calling ctx.wait_for_event(HumanResponseEvent, waiter_event=InputRequiredEvent(...)). The caller sees the InputRequiredEvent in the event stream, collects input (the docs use keyboard input), and sends a HumanResponseEvent back with handler.ctx.send_event; the tool then continues or aborts based on the reply. In AgentWorkflow the active agent can also return control to the user. Because Context serializes, a paused run's state can be saved and restored.

pip install llama-index

import asyncio
from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent
from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-4o-mini")
def word_count(text: str) -> int:
    """Count the words in a piece of text."""
    return len(text.split())

drafter = FunctionAgent(name="Drafter", description="Writes a first draft.", llm=llm, tools=[],
                        system_prompt="Write a two-sentence draft, then hand off to Editor.", can_handoff_to=["Editor"])
editor = FunctionAgent(name="Editor", description="Tightens drafts.", llm=llm, tools=[word_count],
                       system_prompt="Shorten the draft and report its word count.")

workflow = AgentWorkflow(agents=[drafter, editor], root_agent="Drafter")

async def main():
    print(await workflow.run(user_msg="Announce our new office hours: Mondays 9-11."))

asyncio.run(main())

• pip install llama-index is a starter bundle (core, OpenAI LLM and embeddings, file readers); other providers need separate integration packages such as llama-index-llms-ollama.
• The OpenAI defaults need OPENAI_API_KEY; the installation page says the default models are gpt-3.5-turbo and text-embedding-ada-002 unless you pass a model explicitly.
• Imports containing core come from llama-index-core; imports without it come from integration packages that must be installed separately.
• MCP tools need pip install llama-index-tools-mcp; AG-UI needs llama-index-protocols-ag-ui.

Yes. The llama-index-tools-mcp package loads tools from MCP servers (SSE, Streamable HTTP or stdio), and the docs show converting LlamaIndex workflows into MCP servers.

Yes. The first-party llama-index-protocols-ag-ui package creates a FastAPI router that speaks AG-UI, and the AG-UI project lists LlamaIndex as a 1st-party integration. A2A support was not found.

The framework is MIT-licensed. The company's paid product is LlamaParse (document parsing, extraction and indexing), priced separately on its pricing page.

In AgentWorkflow, each FunctionAgent lists the agents it may hand off to in can_handoff_to; the workflow starts at the root agent and switches when an agent hands off.

LlamaIndex.TS existed, but its repository now carries a deprecation notice and is archived, so this record lists Python only.