LLM Calls vs Agents

[gmyrianthous]

Hi there,

I'm currently building a chatbot, where the user input goes through multiple stages, each of which involves a call to an LLM, and eventually generates a final response that's being sent back to the user.

For the sake of simplicity, let's assume three sequential stages:

• Intent Classifier: This is a call to an LLM, where the conversation history is injected into the prompt and classifies the intent of the user
• Handler: Let's assume this is an agent, with tools session and memory service
• QA: This is a call to the final LLM that does quality control of the final response that's about to reach the user

I understand that ADK is suitable for building agents, however, would it make sense for the first stage, which is the Intent Classifier, and doesn't really need to be an agent, to use an LLMAgent, with no tools? What are the pros and cons between building an agent for this use cases, vs, say, simply making an LLM call (with vanilla python, or google-genai package, rather than using ADK)?

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: Using an ADK LLMAgent for your Intent Classifier, even without tools, is a good idea, especially since you have a multi-stage process. ADK provides benefits like modularity, state management, and observability that you wouldn't get from a simple LLM call. This will make your chatbot more robust and easier to manage as it grows.

---

Hi @gmyrianthous, that's a great question!

You're right that for a single, isolated LLM call, using ADK might seem like overkill compared to a direct API call. However, given your multi-stage chatbot architecture (Intent Classifier -> Handler -> QA), using ADK from the very beginning, even for the seemingly simple Intent Classifier, offers several advantages:

1. Modularity and Composition:

Your three stages are a perfect use case for ADK's multi-agent capabilities. You can define each stage as a specialized agent and then compose them into a larger, more complex agent. This "agent team" approach makes your system more modular, easier to test, and simpler to reason about.

For example, you could have:

• An IntentClassifierAgent (as an LLMAgent) that takes the user input and determines the intent.
• A HandlerAgent that receives the intent from the first agent and processes it.
• A QAAgent that reviews the handler's response before sending it to the user.

2. State and Session Management:

ADK provides built-in session and state management, which is crucial for passing context between your different stages. The IntentClassifierAgent could add the classified intent to the agent's state, which the HandlerAgent can then access to inform its own logic. This is cleaner than manually passing data between function calls.

3. Observability:

ADK comes with built-in observability and tracing. By using ADK for all stages, you get a unified view of your entire workflow. You can easily trace a request as it flows through the Intent Classifier, Handler, and QA stages, which is invaluable for debugging and performance monitoring.

4. Consistency and Scalability:

Starting with ADK establishes a consistent framework for your application. As you add more complexity, new tools, or even more stages to your chatbot, you'll already be using a system designed for that kind of growth. ADK is designed to be code-first and model-agnostic, giving you flexibility and control over your agent's architecture.

In summary:

While a simple script might be faster for a single LLM call, the benefits of using ADK—modularity, state management, observability, and scalability—make it a strong choice for your multi-stage chatbot. Using an LLMAgent without tools for your Intent Classifier is a perfectly valid and recommended approach that will set you up for success as your project evolves.

I hope this helps!

---

References:
[1] ADK Docs: Multi-agents
[2] ADK Docs: Custom Agents
[3] ADK Docs: Tutorial - Agent Team
[4] ADK Docs: Sessions
[5] ADK Docs: Observability
[6] ADK Project Overview and Architecture
[7] ADK Docs: About ADK