# Daco Framework

> Declarative Agent & MCP Orchestration — single MCP endpoint orchestrating multiple backends

- **Type:** MCP server
- **Install:** `agentstack add mcp-mnemoclaw-daco-framework`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Mnemoclaw](https://agentstack.voostack.com/s/mnemoclaw)
- **Installs:** 0
- **Category:** [Cloud & Infrastructure](https://agentstack.voostack.com/c/cloud-infrastructure)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Mnemoclaw](https://github.com/Mnemoclaw)
- **Source:** https://github.com/Mnemoclaw/daco-framework

## Install

```sh
agentstack add mcp-mnemoclaw-daco-framework
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# DACO — Declarative Agent & MCP Orchestration

[](https://github.com/contactjccoaching-wq/daco-framework)
[](https://opensource.org/licenses/MIT)

**One MCP endpoint to rule them all.**

> Instead of configuring N separate MCP servers in Claude Desktop, you configure one: DACO. It routes tool calls to the right backend, executes them in parallel when possible, and returns structured results.

The pattern is backend-agnostic. You define backends as simple modules (name prefix → handler function). DACO handles routing, parallel execution, error recovery, and the full MCP protocol over HTTP.

The LLM poses questions. DACO executes.

---

## How It Works

```
Claude Desktop / Any MCP Client
        |
        | (single MCP connection)
        v
   +---------+
   |  DACO   |  Cloudflare Worker
   |  Router |  MCP Streamable HTTP
   +----+----+
        |
   +----+----+----+----+
   |    |    |    |    |
   v    v    v    v    v
 Backend A  B  C  D  ...
```

Each backend is a JS module exporting:
- `TOOLS` — array of MCP tool definitions
- `callBackend(name, args, env)` — handler function

DACO merges all tool lists, dispatches by name prefix, and adds meta-tools on top (`daco_execute_parallel`, `daco_list_backends`).

## Current Backends (reference implementation)

This repo ships with 4 backends as a working example:

| Backend | Prefix | What it does |
|---------|--------|---|
| Smart Rabbit | `smart_rabbit_*` | AI fitness program generation |
| PubMed | `pubmed_*` | Scientific literature search (NCBI) |
| Brave Search | `brave_*` | Real-time web search |
| FitLexicon | `fitlexicon_*` | Exercise database (873 exercises, 8 languages) |

**To adapt DACO to your own use case**, replace these with your own backends. The orchestration layer doesn't care what the backends do.

## Deploy

```bash
npm install
npx wrangler secret put BRAVE_API_KEY
npx wrangler secret put RAPIDAPI_KEY
npx wrangler deploy
```

## Configure in Claude Desktop

```json
{
  "mcpServers": {
    "daco": {
      "url": "https://your-worker.workers.dev/mcp",
      "transport": "http"
    }
  }
}
```

Or via local proxy:

```json
{
  "mcpServers": {
    "daco": {
      "command": "npx",
      "args": ["mcp-remote", "https://your-worker.workers.dev/mcp"]
    }
  }
}
```

## Adding a Backend

1. Create `backends/my-service.js`:

```javascript
export const MY_SERVICE_TOOLS = [{
    name: 'myservice_do_thing',
    description: 'Does the thing',
    inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] }
}];

export async function callMyService(name, args, env) {
    const res = await fetch('https://api.example.com/...', { ... });
    return JSON.stringify(await res.json());
}
```

2. Import in `worker.js`, add to `ALL_TOOLS`, add prefix routing in `dispatchTool()`

That's it. No config files, no plugin system. Just functions.

## Parallel Execution

`daco_execute_parallel` fires multiple tool calls simultaneously:

```
daco_execute_parallel([
  { tool: "pubmed_search", arguments: { query: "hypertrophy" } },
  { tool: "brave_search", arguments: { query: "gym prices 2026" } },
  { tool: "myservice_do_thing", arguments: { query: "..." } }
])
→ All results returned in a single response
```

## Related Projects

- [**immune**](https://github.com/contactjccoaching-wq/immune) — Adaptive memory system — learns patterns from every scan (+85% code quality)
- [**chimera**](https://github.com/contactjccoaching-wq/chimera) — Bio-inspired 3-stage pipeline (Slime Mold → PRISM → Immune)
- [**spinal-loop**](https://github.com/contactjccoaching-wq/spinal-loop) — Neuromuscular-inspired agent routing (cheap models first)
- [**prism-framework**](https://github.com/contactjccoaching-wq/prism-framework) — Multi-agent synthesis via native LLM stochasticity
- [**smartrabbit-mcp**](https://github.com/contactjccoaching-wq/smartrabbit-mcp) — AI workout generator MCP server ([smartrabbitfitness.com](https://www.smartrabbitfitness.com))

---

MIT License — by [Jacques Chauvin](https://github.com/contactjccoaching-wq)

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Mnemoclaw](https://github.com/Mnemoclaw)
- **Source:** [Mnemoclaw/daco-framework](https://github.com/Mnemoclaw/daco-framework)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-mnemoclaw-daco-framework
- Seller: https://agentstack.voostack.com/s/mnemoclaw
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.