With the recent addition of A2A (Agent-to-Agent) protocol support in CleverChatty, it’s now possible to build powerful, intelligent applications—without writing any custom logic. In this blog post, we’ll walk through how to build an Agentic RAG (Retrieval-Augmented Generation) system using CleverChatty.

🤖 What is Agentic RAG?

The term agentic refers to an agent's ability to reason, make decisions, use tools, and interact with other agents or humans intelligently.

In the context of RAG, an Agentic RAG system doesn’t just retrieve documents based on a user’s prompt. Instead, it:

• Preprocesses the user’s query,
• Executes a more contextually refined search,
• Postprocesses the results, summarizing and formatting them,
• And only then returns the final answer to the user.

This kind of intelligent behavior is made possible by using a Large Language Model (LLM) as the core reasoning component.

The goal of a RAG system is to enrich the user’s query with external context, especially when the required information is not available within the LLM itself. This typically involves accessing an organization’s knowledge base—structured or unstructured—and providing relevant data to the LLM to enhance its responses.

Recently, I released a new version of CleverChatty with built-in support for the A2A (Agent-to-Agent) protocol. This addition enables AI agents to call each other as tools, opening the door to more dynamic, modular, and intelligent agent systems.

🔄 What Is the A2A Protocol?

The A2A protocol defines a standard for communication and collaboration between AI agents. It allows one agent to delegate tasks to another, much like how humans might assign work to collaborators with specific expertise.

Many blog posts and articles describe the A2A protocol and provide examples of an A2A client calling an A2A server. However, few explain how an AI agent decides when and why to call another agent in a real scenario.

Let’s consider an example: Imagine there's a specialized AI agent called "Document Summarizer", exposed via the A2A protocol. Another agent — a general-purpose chat assistant with access to an LLM — receives this user query:

In this post, I’m excited to announce a new version of CleverChatty that introduces server mode — unlocking powerful new capabilities for building AI assistants and agents that can interact over the network.

Previously, CleverChatty functioned only as a command-line interface (CLI) for interacting with LLM-based assistants. A typical use case involved a single user chatting with an AI model via the terminal. With this latest update, CleverChatty can now run as a server, enabling:

• Concurrent communication with multiple clients
• Background operation on local or cloud environments
• Integration into distributed agent systems

But that’s not all. The biggest leap forward? Full support for A2A (Agent-to-Agent) protocol.

CleverChatty

In this post, I’ll walk through how to integrate the Mem0 memory model with CleverChatty-CLI, a command-line framework for building AI assistants.

Spoiler: It turned out to be a lot easier than I expected.

Quick Overview of the Projects

Before we dive into the integration, here’s a quick recap of the two key components involved:

• Mem0 “Mem0” (pronounced mem-zero) adds an intelligent memory layer to AI assistants and agents. It enables personalized experiences by remembering user preferences, adapting to their needs, and continuously learning over time. It’s particularly useful for customer support bots, personal assistants, and autonomous agents.

• CleverChatty-CLI A command-line interface for interacting with LLM-based chat systems. It supports MCP (Model Context Protocol), RAG (Retrieval-Augmented Generation), and I plan to add support for A2A (Agent-to-Agent) communication soon. The CLI is built for experimentation, testing, and prototyping AI interactions.

CleverChatty, a lightweight AI Chat tool supporting multiple LLM providers, now includes support for Streamable HTTP with MCP servers. This update enables more flexible and efficient communication with AI models, making integration with custom tools and services even smoother.

🌐 What is CleverChatty?

CleverChatty is a minimalist AI chat interface that works with various large language model (LLM) providers — including OpenAI, Anthropic, Google, and local models like Ollama. It’s designed for users and developers who want a simple, extensible tool that supports MCP-based tool usage.

Until now, CleverChatty only supported STDIO and SSE (Server-Sent Events) as transport protocols for connecting with MCP servers. With the latest update, it now supports Streamable HTTP, expanding compatibility and flexibility.

Over the past couple of months, I’ve been experimenting with the Model Context Protocol (MCP) — building AI agents and tools around it. While the experience has been promising, I’ve noticed a few areas where MCP could be expanded or improved.

These aren’t critical issues, but adding them would make MCP more complete and developer-friendly.

Here’s my current wishlist:

1. A Standard MCP Server Interface
2. Bidirectional Notifications
3. Built-in or Native Transport Layer

Let’s walk through each of these in more detail.