Multi-Agent Collaboration Protocol for coordinated AI software development. Think Obsidian for your AI agents - a living knowledge graph where multiple AI agents collaborate through shared context, intelligent task management, and real-time visualization. Watch your codebase evolve as specialized agents work in parallel, never losing context or stepping on each other's work. Beyond the philosophic
Add this skill
npx mdskills install rinadelph/agent-mcpSophisticated multi-agent orchestration framework with impressive visualization and persistent knowledge graph capabilities
1# Agent-MCP23[](https://deepwiki.com/rinadelph/Agent-MCP)45> 🚀 **Advanced Tool Notice**: This framework is designed for experienced AI developers who need sophisticated multi-agent orchestration capabilities. Agent-MCP requires familiarity with AI coding workflows, MCP protocols, and distributed systems concepts. We're actively working to improve documentation and ease of use. If you're new to AI-assisted development, consider starting with simpler tools and returning when you need advanced multi-agent capabilities.6>7> 💬 **Join the Community**: Connect with us on [Discord](https://discord.gg/7Jm7nrhjGn) to get help, share experiences, and collaborate with other developers building multi-agent systems.89Multi-Agent Collaboration Protocol for coordinated AI software development.1011<div align="center">12 <img src="assets/images/agent-network-viz.png" alt="Agent Network Visualization" width="600">13</div>1415Think **Obsidian for your AI agents** - a living knowledge graph where multiple AI agents collaborate through shared context, intelligent task management, and real-time visualization. Watch your codebase evolve as specialized agents work in parallel, never losing context or stepping on each other's work.1617## Why Multiple Agents?1819Beyond the philosophical issues, traditional AI coding assistants hit practical limitations:20- **Context windows overflow** on large codebases21- **Knowledge gets lost** between conversations22- **Single-threaded execution** creates bottlenecks23- **No specialization** - one agent tries to do everything24- **Constant rework** from lost context and confusion2526## The Multi-Agent Solution2728Agent-MCP transforms AI development from a single assistant to a coordinated team:2930<div align="center">31 <img src="assets/images/dashboard-overview.png" alt="Multi-Agent Collaboration Network" width="800">32</div>3334**Real-time visualization** shows your AI team at work - purple nodes represent context entries, blue nodes are agents, and connections show active collaborations. It's like having a mission control center for your development team.3536### Core Capabilities3738**Parallel Execution**39Multiple specialized agents work simultaneously on different parts of your codebase. Backend agents handle APIs while frontend agents build UI components, all coordinated through shared memory.4041**Persistent Knowledge Graph**4243<div align="center">44 <img src="assets/images/memory-bank.png" alt="Memory Bank Interface" width="800">45</div>4647Your project's entire context lives in a searchable, persistent memory bank. Agents query this shared knowledge to understand requirements, architectural decisions, and implementation details. Nothing gets lost between sessions.4849**Intelligent Task Management**5051<div align="center">52 <img src="assets/images/agent-fleet.png" alt="Agent Fleet Management" width="800">53</div>5455Monitor every agent's status, assigned tasks, and recent activity. The system automatically manages task dependencies, prevents conflicts, and ensures work flows smoothly from planning to implementation.5657## Quick Start5859### Python Implementation (Recommended)6061```bash62# Clone and setup63git clone https://github.com/rinadelph/Agent-MCP.git64cd Agent-MCP6566# Check version requirements67python --version # Should be >=3.1068node --version # Should be >=18.0.069npm --version # Should be >=9.0.07071# If using nvm for Node.js version management72nvm use # Uses the version specified in .nvmrc7374# Configure environment75cp .env.example .env # Add your OpenAI API key76uv venv77uv install7879# Start the server80uv run -m agent_mcp.cli --port 8080 --project-dir path-to-directory8182# Launch dashboard (recommended for full experience)83cd agent_mcp/dashboard && npm install && npm run dev84```8586### Node.js/TypeScript Implementation (Alternative)8788```bash89# Clone and setup90git clone https://github.com/rinadelph/Agent-MCP.git91cd Agent-MCP/agent-mcp-node9293# Install dependencies94npm install9596# Configure environment97cp .env.example .env # Add your OpenAI API key9899# Start the server100npm run server101102# Or use the built version103npm run build104npm start105106# Or install globally107npm install -g agent-mcp-node108agent-mcp --port 8080 --project-dir path-to-directory109```110111## MCP Integration Guide112113### What is MCP?114115The **Model Context Protocol (MCP)** is an open standard that enables AI assistants to securely connect to external data sources and tools. Agent-MCP leverages MCP to provide seamless integration with various development tools and services.116117### Running Agent-MCP as an MCP Server118119Agent-MCP can function as an MCP server, exposing its multi-agent capabilities to MCP-compatible clients like Claude Desktop, Cline, and other AI coding assistants.120121#### Quick MCP Setup122123```bash124# 1. Install Agent-MCP125uv venv126uv install127128# 2. Start the MCP server129uv run -m agent_mcp.cli --port 8080130131# 3. Configure your MCP client to connect to:132# HTTP: http://localhost:8000/mcp133# WebSocket: ws://localhost:8000/mcp/ws134```135136#### MCP Server Configuration137138Create an MCP configuration file (`mcp_config.json`):139140```json141{142 "server": {143 "name": "agent-mcp",144 "version": "1.0.0"145 },146 "tools": [147 {148 "name": "create_agent",149 "description": "Create a new specialized AI agent"150 },151 {152 "name": "assign_task",153 "description": "Assign tasks to specific agents"154 },155 {156 "name": "query_project_context",157 "description": "Query the shared knowledge graph"158 },159 {160 "name": "manage_agent_communication",161 "description": "Handle inter-agent messaging"162 }163 ],164 "resources": [165 {166 "name": "agent_status",167 "description": "Real-time agent status and activity"168 },169 {170 "name": "project_memory",171 "description": "Persistent project knowledge graph"172 }173 ]174}175```176177#### Using Agent-MCP with Claude Desktop1781791. **Add to Claude Desktop Config**:180181 Open `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or equivalent:182183 ```json184 {185 "mcpServers": {186 "agent-mcp": {187 "command": "uv",188 "args": ["run", "-m", "agent_mcp.cli", "--port", "8080"],189 "env": {190 "OPENAI_API_KEY": "your-openai-api-key"191 }192 }193 }194 }195 ```1961972. **Restart Claude Desktop** to load the MCP server1981993. **Verify Connection**: Claude should show "🔌 agent-mcp" in the conversation200201#### MCP Tools Available202203Once connected, you can use these MCP tools directly in Claude:204205**Agent Management**206- `create_agent` - Spawn specialized agents (backend, frontend, testing, etc.)207- `list_agents` - View all active agents and their status208- `terminate_agent` - Safely shut down agents209210**Task Orchestration**211- `assign_task` - Delegate work to specific agents212- `view_tasks` - Monitor task progress and dependencies213- `update_task_status` - Track completion and blockers214215**Knowledge Management**216- `ask_project_rag` - Query the persistent knowledge graph217- `update_project_context` - Add architectural decisions and patterns218- `view_project_context` - Access stored project information219220**Communication**221- `send_agent_message` - Direct messaging between agents222- `broadcast_message` - Send updates to all agents223- `request_assistance` - Escalate complex issues224225#### Advanced MCP Configuration226227**Custom Transport Options**:228```bash229# HTTP with custom port230uv run -m agent_mcp.cli --port 8080231232# WebSocket with authentication233uv run -m agent_mcp.cli --port 8080 --auth-token your-secret-token234235# Unix socket (Linux/macOS)236uv run -m agent_mcp.cli --port 8080237```238239**Environment Variables**:240```bash241export AGENT_MCP_HOST=0.0.0.0 # Server host242export AGENT_MCP_PORT=8000 # Server port243export AGENT_MCP_LOG_LEVEL=INFO # Logging level244export AGENT_MCP_PROJECT_DIR=/your/project # Default project directory245export AGENT_MCP_MAX_AGENTS=10 # Maximum concurrent agents246```247248### MCP Client Examples249250#### Python Client251```python252import asyncio253from mcp import Client254255async def main():256 async with Client("http://localhost:8000/mcp") as client:257 # Create a backend agent258 result = await client.call_tool("create_agent", {259 "role": "backend",260 "specialization": "API development"261 })262263 # Assign a task264 await client.call_tool("assign_task", {265 "agent_id": result["agent_id"],266 "task": "Implement user authentication endpoints"267 })268269 # Query project context270 context = await client.call_tool("ask_project_rag", {271 "query": "What's our current database schema?"272 })273 print(context)274275asyncio.run(main())276```277278#### JavaScript Client279```javascript280import { MCPClient } from '@modelcontextprotocol/client';281282const client = new MCPClient('http://localhost:8000/mcp');283284async function createAgent() {285 await client.connect();286287 const agent = await client.callTool('create_agent', {288 role: 'frontend',289 specialization: 'React components'290 });291292 console.log('Created agent:', agent.agent_id);293294 await client.disconnect();295}296297createAgent().catch(console.error);298```299300### Troubleshooting MCP Connection301302**Connection Issues**:303```bash304# Check if MCP server is running305curl http://localhost:8000/mcp/health306307# Verify WebSocket connection308wscat -c ws://localhost:8000/mcp/ws309310# Check server logs311uv run -m agent_mcp.cli --port 8080 --log-level DEBUG312```313314**Common Issues**:315- **Port conflicts**: Change port with `--port` flag316- **Permission errors**: Ensure OpenAI API key is set317- **Client timeout**: Increase timeout in client configuration318- **Agent limit reached**: Check active agent count with `list_agents`319320### Integration Examples321322**VS Code with MCP**:323Use the MCP extension to integrate Agent-MCP directly into your editor workflow.324325**Terminal Usage**:326```bash327# Quick task assignment via curl328curl -X POST http://localhost:8000/mcp/tools/assign_task \329 -H "Content-Type: application/json" \330 -d '{"task": "Add error handling to API endpoints", "agent_role": "backend"}'331```332333**CI/CD Integration**:334```yaml335# GitHub Actions example336- name: Run Agent-MCP Code Review337 run: |338 uv run -m agent_mcp.cli --port 8080 --daemon339 curl -X POST localhost:8000/mcp/tools/assign_task \340 -d '{"task": "Review PR for security issues", "agent_role": "security"}'341```342343## How It Works: Breaking Complexity into Simple Steps344345```mermaid346graph LR347 A[Step 1] --> B[Step 2] --> C[Step 3] --> D[Step 4] --> E[Done!]348 style A fill:#4ecdc4,color:#fff349 style E fill:#ff6b6b,color:#fff350```351352Every task can be broken down into linear steps. This is the core insight that makes Agent-MCP powerful.353354### The Problem with Complex Tasks355356```mermaid357graph TD358 A["Build User Authentication"] -->|Single Agent Tries Everything| B{???}359 B --> C[Database?]360 B --> D[API?]361 B --> E[Frontend?]362 B --> F[Security?]363 B --> G[Tests?]364 C -.->|Confused| H[Incomplete Implementation]365 D -.->|Overwhelmed| H366 E -.->|Context Lost| H367 F -.->|Assumptions| H368 G -.->|Forgotten| H369 style A fill:#ff6b6b,color:#fff370 style H fill:#666,color:#fff371```372373### The Agent-MCP Solution374375```mermaid376graph TD377 A["Build User Authentication"] -->|Break Down| B[Linear Tasks]378 B --> C["Agent 1: Database"]379 B --> D["Agent 2: API"]380 B --> E["Agent 3: Frontend"]381382 C --> C1[Create users table]383 C1 --> C2[Add indexes]384 C2 --> C3[Create sessions table]385386 D --> D1[POST /register]387 D1 --> D2[POST /login]388 D2 --> D3[POST /logout]389390 E --> E1[Login Form]391 E1 --> E2[Register Form]392 E2 --> E3[Auth Context]393394 C3 --> F[Working System]395 D3 --> F396 E3 --> F397398 style A fill:#4ecdc4,color:#fff399 style F fill:#4ecdc4,color:#fff400```401402Each agent focuses on their linear chain. No confusion. No context pollution. Just clear, deterministic progress.403404## The 5-Step Workflow405406### 1. Initialize Admin Agent407```408You are the admin agent.409Admin Token: "your_admin_token_from_server"410411Your role is to:412- Coordinate all development work413- Create and manage worker agents414- Maintain project context415- Assign tasks based on agent specializations416```417418### 2. Load Your Project Blueprint (MCD)419```420Add this MCD (Main Context Document) to project context:421422[paste your MCD here - see docs/mcd-guide.md for structure]423424Store every detail in the knowledge graph. This becomes the single source of truth for all agents.425```426427The MCD (Main Context Document) is your project's comprehensive blueprint - think of it as writing the book of your application before building it. It includes:428- Technical architecture and design decisions429- Database schemas and API specifications430- UI component hierarchies and workflows431- Task breakdowns with clear dependencies432433See our [MCD Guide](./docs/mcd-guide.md) for detailed examples and templates.434435### 3. Deploy Your Agent Team436```437Create specialized agents for parallel development:438439- backend-worker: API endpoints, database operations, business logic440- frontend-worker: UI components, state management, user interactions441- integration-worker: API connections, data flow, system integration442- test-worker: Unit tests, integration tests, validation443- devops-worker: Deployment, CI/CD, infrastructure444```445446Each agent specializes in their domain, leading to higher quality implementations and faster development.447448### 4. Initialize and Deploy Workers449```450# In new window for each worker:451You are [worker-name] agent.452Your Admin Token: "worker_token_from_admin"453454Query the project knowledge graph to understand:4551. Overall system architecture4562. Your specific responsibilities4573. Integration points with other components4584. Coding standards and patterns to follow4595. Current implementation status460461Begin implementation following the established patterns.462463AUTO --worker --memory464```465466**Important: Setting Agent Modes**467468Agent modes (like `--worker`, `--memory`, `--playwright`) are not just flags - they activate specific behavioral patterns. In Claude Code, you can make these persistent by:4694701. Copy the mode instructions to your clipboard4712. Type `#` to open Claude's memory feature4723. Paste the instructions for persistent behavior473474Example for Claude Code memory:475```476# When I use "AUTO --worker --memory", follow these patterns:477- Always check file status before editing478- Query project RAG for context before implementing479- Document all changes in task notes480- Work on one file at a time, completing it before moving on481- Update task status after each completion482```483484This ensures consistent behavior across your entire session without repeating instructions.485486### 5. Monitor and Coordinate487488The dashboard provides real-time visibility into your AI development team:489490**Network Visualization** - Watch agents collaborate and share information491**Task Progress** - Track completion across all parallel work streams492**Memory Health** - Ensure context remains fresh and accessible493**Activity Timeline** - See exactly what each agent is doing494495Access at `http://localhost:3847` after launching the dashboard.496497## Advanced Features498499### Specialized Agent Modes500501Agent modes fundamentally change how agents behave. They're not just configuration - they're behavioral contracts that ensure agents follow specific patterns optimized for their role.502503**Standard Worker Mode**504```505AUTO --worker --memory506```507Optimized for implementation tasks:508- Granular file status checking before any edits509- Sequential task completion (one at a time)510- Automatic documentation of changes511- Integration with project RAG for context512- Task status updates after each completion513514**Frontend Specialist Mode**515```516AUTO --worker --playwright517```518Enhanced with visual validation capabilities:519- All standard worker features520- Browser automation for component testing521- Screenshot capabilities for visual regression522- DOM interaction for end-to-end testing523- Component-by-component implementation with visual verification524525**Research Mode**526```527AUTO --memory528```529Read-only access for analysis and planning:530- No file modifications allowed531- Deep context exploration via RAG532- Pattern identification across codebase533- Documentation generation534- Architecture analysis and recommendations535536**Memory Management Mode**537```538AUTO --memory --manager539```540For context curation and optimization:541- Memory health monitoring542- Stale context identification543- Knowledge graph optimization544- Context summarization for new agents545- Cross-agent knowledge transfer546547Each mode enforces specific behaviors that prevent common mistakes and ensure consistent, high-quality output.548549### Project Memory Management550551The system maintains several types of memory:552553**Project Context** - Architectural decisions, design patterns, conventions554**Task Memory** - Current status, blockers, implementation notes555**Agent Memory** - Individual agent learnings and specializations556**Integration Points** - How different components connect557558All memory is:559- Searchable via semantic queries560- Version controlled for rollback561- Tagged for easy categorization562- Automatically garbage collected when stale563564### Conflict Resolution565566File-level locking prevents agents from overwriting each other's work:5675681. Agent requests file access5692. System checks if file is locked5703. If locked, agent works on other tasks or waits5714. After completion, lock is released5725. Other agents can now modify the file573574This happens automatically - no manual coordination needed.575576## Short-Lived vs. Long-Lived Agents: The Critical Difference577578### Traditional Long-Lived Agents579Most AI coding assistants maintain conversations across entire projects:580- **Accumulated context grows unbounded** - mixing unrelated code, decisions, and conversations581- **Confused priorities** - yesterday's bug fix mingles with today's feature request582- **Hallucination risks increase** - agents invent connections between unrelated parts583- **Performance degrades over time** - every response processes irrelevant history584- **Security vulnerability** - one carefully crafted prompt could expose your entire project585586### Agent-MCP's Ephemeral Agents587Each agent is purpose-built for a single task:588- **Minimal, focused context** - only what's needed for the specific task589- **Crystal clear objectives** - one task, one goal, no ambiguity590- **Deterministic behavior** - limited context means predictable outputs591- **Consistently fast responses** - no context bloat to slow things down592- **Secure by design** - agents literally cannot access what they don't need593594### A Practical Example595596**Traditional Approach**: "Update the user authentication system"597```598Agent: I'll update your auth system. I see from our previous conversation about599database migrations, UI components, API endpoints, deployment scripts, and that600bug in the payment system... wait, which auth approach did we decide on? Let me601try to piece this together from our 50+ message history...602603[Agent produces confused implementation mixing multiple patterns]604```605606**Agent-MCP Approach**: Same request, broken into focused tasks607```608Agent 1 (Database): Create auth tables with exactly these fields...609Agent 2 (API): Implement /auth endpoints following REST patterns...610Agent 3 (Frontend): Build login forms using existing component library...611Agent 4 (Tests): Write auth tests covering these specific scenarios...612Agent 5 (Integration): Connect components following documented interfaces...613614[Each agent completes their specific task without confusion]615```616617## The Theory Behind Linear Decomposition618619### The Philosophy: Short-Lived Agents, Granular Tasks620621Most AI development approaches suffer from a fundamental flaw: they try to maintain massive context windows with a single, long-running agent. This leads to:622623- **Context pollution** - Irrelevant information drowns out what matters624- **Hallucination risks** - Agents invent connections between unrelated parts625- **Security vulnerabilities** - Agents with full context can be manipulated626- **Performance degradation** - Large contexts slow down reasoning627- **Unpredictable behavior** - Too much context creates chaos628629### Our Solution: Ephemeral Agents with Shared Memory630631Agent-MCP implements a radically different approach:632633**Short-Lived, Focused Agents**634Each agent lives only as long as their specific task. They:635- Start with minimal context (just what they need)636- Execute granular, linear tasks with clear boundaries637- Document their work in shared memory638- Terminate upon completion639640**Shared Knowledge Graph (RAG)**641Instead of cramming everything into context windows:642- Persistent memory stores all project knowledge643- Agents query only what's relevant to their task644- Knowledge accumulates without overwhelming any single agent645- Clear separation between working memory and reference material646647**Result**: Agents that are fast, focused, and safe. They can't be manipulated to reveal full project details because they never have access to it all at once.648649### Why This Matters for Safety650651Traditional long-context agents are like giving someone your entire codebase, documentation, and secrets in one conversation. Our approach is like having specialized contractors who only see the blueprint for their specific room.652653- **Reduced attack surface** - Agents can't leak what they don't know654- **Deterministic behavior** - Limited context means predictable outputs655- **Audit trails** - Every agent action is logged and traceable656- **Rollback capability** - Mistakes are isolated to specific tasks657658### The Cleanup Protocol: Keeping Your System Lean659660Agent-MCP enforces strict lifecycle management:661662**Maximum 10 Active Agents**663- Hard limit prevents resource exhaustion664- Forces thoughtful task allocation665- Maintains system performance666667**Automatic Cleanup Rules**668- Agent finishes task → Immediately terminated669- Agent idle 60+ seconds → Killed and task reassigned670- Need more than 10 agents → Least productive agents removed671672**Why This Matters**673- **No zombie processes** eating resources674- **Fresh context** for every task675- **Predictable resource usage**676- **Clean system state** always677678This isn't just housekeeping - it's fundamental to the security and performance benefits of the short-lived agent model.679680### The Fundamental Principle681682**Any task that cannot be expressed as `Step 1 → Step 2 → Step N` is not atomic enough.**683684This principle drives everything in Agent-MCP:6856861. **Complex goals** must decompose into **linear sequences**6872. **Linear sequences** can execute **in parallel** when independent6883. **Each step** must have **clear prerequisites** and **deterministic outputs**6894. **Integration points** are **explicit** and **well-defined**690691### Why Linear Decomposition Works692693**Traditional Approach**: "Build a user authentication system"694- Vague requirements lead to varied implementations695- Agents make different assumptions696- Integration becomes a nightmare697698**Agent-MCP Approach**:699```700Chain 1: Database Layer701 1.1: Create users table with id, email, password_hash702 1.2: Add unique index on email703 1.3: Create sessions table with user_id, token, expiry704 1.4: Write migration scripts705706Chain 2: API Layer707 2.1: Implement POST /auth/register endpoint708 2.2: Implement POST /auth/login endpoint709 2.3: Implement POST /auth/logout endpoint710 2.4: Add JWT token generation711712Chain 3: Frontend Layer713 3.1: Create AuthContext provider714 3.2: Build LoginForm component715 3.3: Build RegisterForm component716 3.4: Implement protected routes717```718719Each step is atomic, testable, and has zero ambiguity. Multiple agents can work these chains in parallel without conflict.720721## Why Developers Choose Agent-MCP722723**The Power of Parallel Development**724Instead of waiting for one agent to finish the backend before starting the frontend, deploy specialized agents to work simultaneously. Your development speed is limited only by how well you decompose tasks.725726**No More Lost Context**727Every decision, implementation detail, and architectural choice is stored in the shared knowledge graph. New agents instantly understand the project state without reading through lengthy conversation histories.728729**Predictable, Reliable Outputs**730Focused agents with limited context produce consistent results. The same task produces the same quality output every time, making development predictable and testable.731732**Built-in Conflict Prevention**733File-level locking and task assignment prevent agents from stepping on each other's work. No more merge conflicts from simultaneous edits.734735**Complete Development Transparency**736Watch your AI team work in real-time through the dashboard. Every action is logged, every decision traceable. It's like having a live view into your development pipeline.737738**For Different Team Sizes**739740**Solo Developers**: Transform one AI assistant into a coordinated team. Work on multiple features simultaneously without losing track.741742**Small Teams**: Augment human developers with AI specialists that maintain perfect context across sessions.743744**Large Projects**: Handle complex systems where no single agent could hold all the context. The shared memory scales infinitely.745746**Learning & Teaching**: Perfect for understanding software architecture. Watch how tasks decompose and integrate in real-time.747748## System Requirements749750- **Python**: 3.10+ with pip or uv751- **Node.js**: 18.0.0+ (recommended: 22.16.0)752- **npm**: 9.0.0+ (recommended: 10.9.2)753- **OpenAI API key** (for embeddings and RAG)754- **RAM**: 4GB minimum755- **AI coding assistant**: Claude Code or Cursor756757For consistent development environment:758```bash759# Using nvm (Node Version Manager)760nvm use # Automatically uses Node v22.16.0 from .nvmrc761762# Or manually check versions763node --version # Should be >=18.0.0764npm --version # Should be >=9.0.0765python --version # Should be >=3.10766```767768## Troubleshooting769770**"Admin token not found"**771Check the server startup logs - token is displayed when MCP server starts.772773**"Worker can't access tasks"**774Ensure you're using the worker token (not admin token) when initializing workers.775776**"Agents overwriting each other"**777Verify all workers are initialized with the `--worker` flag for proper coordination.778779**"Dashboard connection failed"**7801. Ensure MCP server is running first7812. Check Node.js version (18+ required)7823. Reinstall dashboard dependencies783784**"Memory queries returning stale data"**785Run memory garbage collection through the dashboard or restart with `--refresh-memory`.786787## Documentation788789- [Getting Started Guide](./docs/getting-started.md) - Complete walkthrough with examples790- [MCD Creation Guide](./docs/mcd-guide.md) - Write effective project blueprints791- [Theoretical Foundation](./docs/chapter-1-cognitive-empathy.md) - Understanding AI cognition792- [Architecture Overview](./docs/architecture.md) - System design and components793- [API Reference](./docs/api-reference.md) - Complete technical documentation794795## Community and Support796797**Get Help**798- [Discord Community](https://discord.gg/7Jm7nrhjGn) - Active developer discussions799- [GitHub Issues](https://github.com/rinadelph/Agent-MCP/issues) - Bug reports and features800- [Discussions](https://github.com/rinadelph/Agent-MCP/discussions) - Share your experiences801802**Contributing**803We welcome contributions! See our [Contributing Guide](CONTRIBUTING.md) for:804- Code style and standards805- Testing requirements806- Pull request process807- Development setup808809## License810811[](https://www.gnu.org/licenses/agpl-3.0)812813This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**.814815**What this means:**816- ✅ You can use, modify, and distribute this software817- ✅ You can use it for commercial purposes818- ⚠️ **Important**: If you run a modified version on a server that users interact with over a network, you **must** provide the source code to those users819- ⚠️ Any derivative works must also be licensed under AGPL-3.0820- ⚠️ You must include copyright notices and license information821822See the [LICENSE](LICENSE) file for complete terms and conditions.823824**Why AGPL?** We chose AGPL to ensure that improvements to Agent-MCP benefit the entire community, even when used in server/SaaS deployments. This prevents proprietary forks that don't contribute back to the ecosystem.825826---827828Built by developers who believe AI collaboration should be as sophisticated as human collaboration.
Full transparency — inspect the skill content before installing.