What is the difference between FunctionCallingAgent and FunctionAgent

[nguyenkien1402]

I'm reading the new development from the LlamaIndex workflow and come across the new implementation
from llama_index.core.agent.workflow import FunctionAgent

I'm curious on what is the main difference between this FunctionAgent and FunctionCallingAgent from core?

From what I see in the example

FunctionAgent seems to play very well with Agent Workflow so it is more freestyle that let agent to choose and do based on the system prompt

FunctionCallingAgent on the other hand, more like tools calling and can live inside the workflow

I like the idea of can_handoff_to in the FunctionCalling and would be great if we can discuss to possbility to have FunctionAgent to work with LlamaIndex Workflow. I also like the context management of the FunctionAgent.

It seems like FunctionAgent only work with AgentWorkflow?

How can we combine them?

[dosubot[bot]]

Hello @nguyenkien1402! I'm here to help you with any questions or issues you have. Let's tackle this FunctionAgent and FunctionCallingAgent difference together!

The FunctionAgent and FunctionCallingAgent in the LlamaIndex framework have distinct roles and functionalities, although specific details about FunctionCallingAgent are not fully available in the provided context.

1. FunctionAgent:

   • It is designed to work with a FunctionCallingLLM, allowing it to handle function calls within the workflow.
   • It integrates well with the AgentWorkflow, enabling agents to perform tasks based on system prompts and manage context through a "scratchpad" for ongoing interactions.
   • It supports asynchronous tool calls and manages tool call results, making it suitable for complex workflows that require function calling and tool integration ^[1].

2. FunctionCallingAgent:

   • While specific details are not provided, it appears to focus on tool calling and can be integrated into workflows.
   • The can_handoff_to feature suggests it has capabilities for delegating tasks or managing transitions between different agents or tools.

Combining them could potentially leverage the strengths of both: the context management and flexibility of FunctionAgent with the tool-calling capabilities of FunctionCallingAgent. However, specific implementation details or examples of combining them are not available in the current context.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[logan-markewich]

@nguyenkien1402 The FunctionAgent is basically a refactor of the FunctionCallingAgent. Its the same logic, but as you noted, FunctionAgent works specifically with workflows well. Tbh, its meant to replace the older agents like FunctionCallingAgent and ReAactAgent

They are not meant to be combined, they are doing the same thing, just in different ways.

You can always create a single workflow agent and use that inside of other workflows, or on its own.

agent = AgentWorkflow(
  agents=[FunctionAgent(...)]
)

Or alternatively

agent = AgentWorkflow.from_tools_or_functions(
  tools,
  llm=llm,
  system_prompt=system_prompt,
)

(The above do the same thing)

Then, you can just use it

# single shot
resp = agent.run("Hello!")

# with memory/context
from llama_index.core.workflow import Context
ctx = Context(agent)
resp = agent.run("Hello! My name is Logan", ctx=ctx)
resp = agent.run("What is my name?", ctx=ctx)

This is functionally the same as using FunctionCallingAgent