What is Mnemo

Mnemo is a modular agent framework built on the Model Context Protocol (MCP), designed to orchestrate Retrieval-Augmented Generation (RAG) pipelines and intelligent agent workflows using real-time, pluggable data services.

Use cases

Use cases for Mnemo include creating intelligent chatbots, automated data analysis tools, real-time decision support systems, and integrating various data sources into cohesive workflows.

How to use

To use Mnemo, developers can integrate it with any MCP-compliant data or tool service, build modular agents that can chain tasks, and deploy real-time RAG pipelines with multi-modal inputs.

Key features

Key features include MCP-oriented design for hot-swappable interfaces, first-class support for RAG workflows, a composable agent engine for modular agents, and real-time tool calls for dynamic data retrieval.

Where to use

Mnemo can be used in various fields including autonomous workflows, human-in-the-loop systems, and live decision-making agents powered by streaming data from on-chain or enterprise sources.

Mnemo

Composable AI Agents & Realtime Data Interfaces Powered by Model Context Protocol CA:0x7bfdb47ab24b6cb7017865431179e150d4bc4444

Overview

Mnemo is a modular agent framework built on top of the Model Context Protocol (MCP), designed to orchestrate Retrieval-Augmented Generation (RAG) pipelines and intelligent agent workflows using real-time, pluggable data services.

Mnemo integrates two emerging standards:

1. Model Context Protocol (MCP): Enables real-time, protocol-based interaction with external tools, data streams, and services via MCP servers.
2. Composable Agent Architecture: Inspired by effective production patterns, Mnemo allows developers to build, chain, and orchestrate modular agents across tasks and domains.

Why Mnemo?

Mnemo is purpose-built to:

• 🔌 Plug into any MCP-compliant data or tool service
• 🔍 Enable real-time RAG pipelines with multi-modal inputs
• 🧠 Build chainable, domain-specific agents with memory, logic and persistence
• 🧩 Expose agents as MCP clients or servers, enabling two-way integration

Whether you’re building autonomous workflows, human-in-the-loop systems, or live decision agents powered by streaming on-chain or enterprise data—Mnemo provides the infrastructure layer to deploy them quickly.

Features

• ⚙️ MCP-Oriented Design: Fully compatible with MCP server/client pattern; enables hot-swappable data interfaces and execution environments.
• 📚 RAG-Native Agent Workflows: First-class support for Retrieval-Augmented Generation with vector store and unstructured data integration.
• 🤖 Composable Agent Engine: Build modular agents that orchestrate, call tools, persist memory, and coordinate via workflows.
• 🪝 Real-Time Tool Calls: Automatically fetch, retrieve, and operate on data exposed by any MCP-compliant service (e.g., filesystem, fetch, email, SQL, vector DBs).
• 🧪 Multi-Agent Orchestration: Supports cooperative task planning, evaluation agents, and Swarm-style distributed processing.

Installation

We recommend using uv to manage your Python environments:

uv add "mnemo"

Or simply use pip:

pip install mnemo

Quickstart

Clone the repo and run a basic demo agent:

cd examples/basic/mnemo_demo_agent
cp mnemo.secrets.yaml.example mnemo.secrets.yaml  # Add your API keys
uv run main.py

Example: File and Web Agent

from mnemo.app import MnemoApp
from mnemo.agents.agent import Agent
from mnemo.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM

app = MnemoApp(name="web_reader_agent")

async def run():
    async with app.run() as session:
        reader = Agent(
            name="finder",
            instruction="""
            You can read files and browse web links. Return requested information on demand.
            """,
            server_names=["filesystem", "fetch"],
        )

        async with reader:
            tools = await reader.list_tools()
            llm = await reader.attach_llm(OpenAIAugmentedLLM)

            output = await llm.generate_str("Read me the first 10 lines of README.md")
            print("README preview:", output)

            result = await llm.generate_str("Summarize this article: https://www.anthropic.com/research/building-effective-agents")
            print("Summary:", result)

Applications

✅ RAG-Enhanced Q&A

Integrate with vector DBs (e.g. Qdrant, Weaviate) to retrieve relevant text passages and enable context-rich answering.

🧾 Enterprise Memory Agents

Deploy agents with long-term memory over internal knowledge, business logic, or customer records.

📡 On-Chain Analytics Agents

Stream blockchain data via MCP-compatible servers and perform structured analysis or alerts.

🛠️ Custom Toolchains

Create domain-specific agents that orchestrate tasks using external APIs or plugins via the MCP layer.

🧠 Multimodal Reasoning

Extend beyond text: support for image embeddings, structured documents, web interfaces, and speech-ready agents.

Roadmap

• ✅ Multi-agent Swarm workflows (inspired by OpenAI’s Swarm)
• ✅ Long-running workflow orchestration with pause/resume
• ⏳ Persistent agent memory & streaming input support
• 🧠 LLM model switch support (Claude, GPT-4o, etc.)
• 🧩 More MCP server connectors: calendar, cloud docs, database, sensors

Credits

Built with ❤️ on top of MCP and inspired by Anthropic’s vision for composable, intelligent agents.