Mangaba AI Multi-Agent Framework

Mangaba AI is a system for creating intelligent AI agents, primarily based on Google Generative AI (Gemini). It is designed for high scalability and is optimized for Brazilian Portuguese. The system is built around two core communication and management protocols: A2A (Agent-to-Agent) for seamless communication between multiple agents, and MCP (Model Context Protocol) for intelligent context management.

Core Components

• Main Agent: Handles Chat, Analysis, and Translation.
• MCP Protocol: Manages Context, Sessions, and Search.
• A2A Protocol: Enables P2P communication, Broadcast capabilities, and Handlers.
• Supporting Modules: Config, Logger, and Utils.

Mangaba AI is a Brazilian framework for creating AI agents. It is built around three core pillars:

• Main Agent: Powered by Google Generative AI (Gemini).
• A2A Protocol: Enables communication between multiple agents.
• MCP Protocol: Provides intelligent context management.

It is designed for high scalability and use cases such as document analysis, virtual assistants, process automation, translation, and data analysis.

When orchestrating multiple agents using a Crew, you can choose from four distinct execution strategies (processes) depending on your workflow requirements:

• SEQUENTIAL: Tasks are executed one after another in a linear order. Best for linear workflows.
• HIERARCHICAL: A manager agent delegates tasks and reviews each delivery. Best for teams with a leader.
• PARALLEL: Tasks are executed concurrently using asyncio. Best for independent tasks.
• CONSENSUAL: All agents execute every task, and the results are synthesized. Best for critical decision-making processes.

User Context is a specific type of MCP context used to store information about a user, such as:

• Name and role
• Company and sector
• Response preferences
• Interaction history

When calling the .search() method, the store returns a list of dictionaries. Each dictionary represents a retrieved document and includes the following keys:

• id: The unique identifier of the vector.
• content: The original text associated with the vector.
• score: The similarity score (e.g., cosine similarity).
• metadata: A dictionary containing any additional metadata provided during the add step.

# Example return structure:
[
    {"id": "abc123", "content": "...", "score": 0.95, "metadata": {...}},
    {"id": "def456", "content": "...", "score": 0.87, "metadata": {...}},
]

The MCPProtocol allows you to manage conversation contexts, maintain history, and inject relevant information into the agent's state. You can add context using the .add_context() method with a content string, a context_type, and a priority level.

from mangaba_agent import MangabaAgent
from protocols.mcp import MCPProtocol

# Create agent with MCP
agent = MangabaAgent()
mcp = MCPProtocol()
agent.add_protocol(mcp)

# Add context
mcp.add_context(
    content="Usuário trabalha em uma empresa de tecnologia",
    context_type="user_info",
    priority=1
)

# Chat with context
resposta = agent.chat("Que tipo de projetos posso desenvolver?")
print(resposta)

Mangaba AI provides a complete pipeline for Retrieval-Augmented Generation (RAG). The workflow follows this sequence:

1. Document: The raw data.
2. Loader: Converts raw data into Document objects.
3. Splitter: Breaks large documents into smaller chunks.
4. Embedding: Converts text chunks into numerical vectors.
5. VectorStore: Stores the vectors for efficient retrieval.
6. Retriever: Bridges the embedding model and the vector store to find relevant documents.
7. RAGChain: Combines the LLM and the Retriever to answer questions based on the retrieved context.

Data Flow: Document → Loader → Splitter → Embedding → VectorStore Query → Embedding → Retriever → Top-K Documents → RAGChain → Answer

Mangaba supports advanced agent behaviors:

• Reasoning: Enable an agent to plan and critique its own plan before acting using reasoning=True and max_reasoning_attempts.
• Planning: A Crew can plan all tasks before execution using planning=True.
• Hierarchical Process: Use process=Process.HIERARCHICAL with a manager_llm to have a dedicated manager agent choose which agent performs which task and review/reject outputs.

# Agent with reasoning
agente = Agent(role="Analista", goal="...", backstory="...",
               reasoning=True, max_reasoning_attempts=3)

# Crew with hierarchical planning
crew = Crew(
    agents=[pesquisador, analista, redator],
    tasks=[t1, t2, t3],
    process=Process.HIERARCHICAL,
    planning=True,
    manager_llm=create_llm_client(provider="openai", api_key="..."),
)

A Session in the Model Context Protocol (MCP) groups related contexts, allowing for the isolation of different conversations or users.

Available operations for a session include:

• Creating a new session
• Adding contexts to the session
• Searching for contexts within the session
• Clearing or deleting a session