Serveur MCP Agentic
Commit 22 oct. 2026Permet à un client IA de découvrir et d'appeler des MCP servers à la demande via un chargement paresseux (lazy loading) en trois couches, réduisant ainsi la consommation de tokens sans nécessiter l'installation préalable de listes d'outils complètes.
Aussi connu sous cablate/Agentic-MCP-Skill
- Étoiles
- 41
- Outils
- —
- Téléchargements, 30 jours
- —
- Dernière version
- —
- Dernier commit
- 22 oct. 2026
- Licence
- —
Qu'est-ce que Agentic MCP ?
Agentic est un serveur MCP. Permet à un client IA de découvrir et d'appeler des MCP servers à la demande via un chargement paresseux (lazy loading) en trois couches, réduisant ainsi la consommation de tokens sans nécessiter l'installation préalable de listes d'outils complètes.
Résumé généré à partir du README du projet
À propos du MCP server Agentic
Les développeurs cherchant à optimiser l'utilisation de la fenêtre de contexte de l'IA peuvent utiliser cet outil pour gérer les serveurs Model Context Protocol via une stratégie de divulgation progressive. Au lieu de charger tous les outils disponibles dans un client IA en une seule fois, ce qui consomme un nombre important de tokens, ce système utilise une approche en trois couches pour ne récupérer que les informations nécessaires. Il commence par les métadonnées de base du serveur, passe aux listes d'outils, et charge enfin les schémas d'entrée spécifiques uniquement lorsqu'un outil est prêt à être appelé.
Ce projet expérimental fonctionne via une architecture de daemon basée sur des sockets qui maintient des connexions persistantes avec divers MCP servers tels que Playwright ou des outils de système de fichiers. Les utilisateurs configurent leur environnement via un fichier JSON et interagissent avec le système à l'aide d'une interface en ligne de commande. En implémentant ce modèle de chargement paresseux, les développeurs peuvent réaliser des économies substantielles de tokens, réduisant potentiellement le coût de gestion d'un large ensemble d'outils de plus de 80 % par rapport aux méthodes traditionnelles.
Ce que vous pouvez faire avec
- 1Réduire la consommation de tokens IAUn client IA peut parcourir les outils disponibles et ne charger le schéma d'entrée complet que pour l'outil spécifique qu'il a l'intention d'utiliser.
- 2Gérer plusieurs MCP serversUn développeur peut configurer et exécuter divers MCP servers comme Playwright ou GitHub via un seul daemon.
- 3Automatiser des tâches de navigation webVous pouvez ordonner à une IA de naviguer sur des sites web, de prendre des captures d'écran ou de cliquer sur des éléments en utilisant l'intégration Playwright.
- 4Mettre à jour les configurations de serveurs en directVous pouvez modifier votre liste de serveurs dans le fichier de configuration et appliquer les changements sans arrêter le daemon.
Extrait du README du projet. Chaque cas d'utilisation est vérifié par rapport à une citation du document.
Vérifications automatisées
Exécuté le 14 nov. 2026Rapport complet →Pas encore vérifié. Un serveur nécessite un score de 80, aucune faille sérieuse et suffisamment de données pour que nous puissions effectuer les vérifications. Fonctionnement des vérifications · Ce qu'il faut corriger pour gagner des points
- Dépôt source lié et accessiblecablate/agentic-mcp-skill is public and reachablegithub.com/cablate/agentic-mcp-skill ↗Réussi
- Le nom du package correspond au dépôt sourceNon vérifié
- Provenance du build (attestation Sigstore)Non vérifié
- Licence open source (OSI)No licenseFaille
- Commit ou version publiée au cours de l'année écouléeLast commit or release 2026-10-22github.com/cablate/agentic-mcp-skill ↗Réussi
- OpenSSF ScorecardNon vérifié
- Nom du package non proche d'un package populaireNon vérifié
- Aucun avis critique dans le package ou ses dépendancesNon vérifié
- Aucune instruction cachée destinée au modèle0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersRéussi
- Les outils destructifs sont étiquetésNon vérifié
- Le point de terminaison distant répond à la poignée de main MCPNon vérifié
README
Voir sur GitHubAgentic-MCP with Skill
AgentSkill for MCP - Three-layer progressive disclosure validates AgentSkills.io pattern for efficient MCP token usage
Design Intent
Proven AgentSkills Pattern
In the AgentSkills.io ecosystem, Progressive Disclosure combined with Script linkage has been validated as effective:
- AI only loads specific information when needed, significantly reducing token usage
- Scripts can be invoked via AI commands, providing high customization potential
- Sharing tools via scripts is far less costly than developing and using complex MCP Servers
The impact of this pattern is significant and substantial.
Current MCP Skill Dilemma
Despite this, many Skills using MCP still face two extreme options:
Option 1: Install MCP directly in Claude Code, Skill only guides AI to call MCP
- MCP server occupies AI context long-term
- Full tool list loaded every conversation
- Token waste, and MCP itself cannot be progressively explored
Option 2: Write custom scripts yourself
- Tests user's programming skills
- High customization but lacks standards
- Each MCP has its own format/specs, high adaptation cost for both open and closed source
- Difficult to maintain and share
This Skill's Goal
Validate whether AgentSkills.io pattern applies to improving MCP usage
This concept validation attempts to port AgentSkills' successful pattern to the MCP domain:
- Can AgentSkills architecture apply to MCP server management?
- Is three-layer progressive disclosure effective in MCP scenarios?
- Is Socket-based daemon architecture more practical than direct MCP usage?
Experimental Nature
This is not a mature product, but an experiment:
- Test AgentSkills pattern applicability in MCP domain
- Explore actual effectiveness of three-layer loading
- Validate pros/cons of Daemon architecture
- Serve as reference prototype for future development
Important Disclaimer
This is a very early, rushed AI-assisted demo version with current goals:
- Validate concept feasibility
- Explore usage patterns
- Collect feedback for improvements
Not recommended for production use. Expect many issues and optimization opportunities. If you find any problems or have suggestions, please open an Issue or contribute a PR.
Core Concepts
Three-Layer Progressive Disclosure
Like AgentSkills, you don't need to load everything at once:
Layer 1: Know which servers are available
Load only basic info (name, version, status)
Usage: ~50-100 tokens
Use case: Check availability, choose server
Layer 2: Know what tools this server provides
Load tool list (names + brief descriptions)
Usage: ~200-400 tokens
Use case: Browse available tools, decide what to use
Layer 3: Load only the tools you need
Load complete input format for specific tool
Usage: ~300-500 tokens/tool
Use case: Before calling tool
Why This Approach
Assume an MCP server has 20 tools, you only need 2:
| Loading Method | Token Usage | Description |
|---|---|---|
| Load All | 6,000 | 20 tools × 300 tokens |
| Three-Layer Progressive | 850 | Metadata(50) + List(200) + 2 tools(600) |
| Savings | 86% | Only load what you need |
Development Status
Future Plans
Based on concept validation results, future directions include:
Short-term Goals
- More convenient MCP Servers management (UI, auto-discovery, one-click install)
- Implement Auth features (API Key management, permission control)
Mid-term Goals
- Enhance MCP Server tool calling experience (better error messages, parameter validation, result formatting)
- Intercept MCP Server output with customizable Script data processing, avoid massive messy data entering conversation memory
This project's direction depends on:
- Concept validation results
- Community feedback
- Actual usage needs
Feedback and suggestions welcome.
Quick Start
Prerequisites
- Node.js >= 18.0.0
- npm
1. Install from npm (Recommended)
# Install globally
npm install -g @cablate/agentic-mcp
# Verify installation
agentic-mcp --version
# Start daemon
agentic-mcp daemon start
2. Configure
Edit mcp-servers.json in the project root:
{
"servers": {
"playwright": {
"description": "Browser automation tool for web navigation, screenshots, clicks, form filling, and more",
"type": "stdio",
"command": "npx",
"args": ["@playwright/mcp@latest", "--isolated"]
}
}
}
3. Start Daemon
node dist/cli/index.js daemon start --config <config-path>
4. Test Connection
# Check daemon health
agentic-mcp daemon health
# Layer 1: Check server status
agentic-mcp metadata playwright
# Layer 2: List available tools
agentic-mcp list playwright
# Layer 3: View specific tool format
agentic-mcp schema playwright browser_navigate
5. Call Tool
agentic-mcp call playwright browser_navigate --params '{"url": "https://example.com"}'
Testing
This project uses Vitest for testing with the following test suites:
Running Tests
# Run tests in watch mode
npm test
# Run tests once
npm run test:run
# Run with coverage report
npm run test:coverage
Test Structure
tests/
├── unit/
│ ├── client.test.ts # ProgressiveMCPClient tests (12 tests)
│ ├── socket-client.test.ts # SocketClient tests (7 tests)
│ └── cli/
│ └── commands.test.ts # CLI command tests (6 tests)
Current Coverage
- Statements: 61.71%
- Branches: 47.29%
- Functions: 65.85%
- Lines: 61.53%
Test coverage focuses on core modules (client.ts, socket-client.ts). Daemon integration tests are deferred to future work.
Test Philosophy
This project follows a pragmatic progressive approach:
- Focus on happy path testing first
- Use real MCP server (
@modelcontextprotocol/server-filesystem) for integration - Mock only where necessary (e.g.,
netmodule for SocketClient) - Defer complex scenarios (daemon socket tests) to keep initial implementation simple
Usage Examples
Web Automation
Automate browser operations using Playwright MCP server:
# 1. Navigate to website
agentic-mcp call playwright browser_navigate --params '{"url": "https://www.apple.com/tw"}'
# 2. Take screenshot
agentic-mcp call playwright browser_take_screenshot
# 3. Click element
agentic-mcp call playwright browser_click --params '{"element": "Mac link", "ref": "e19"}'
Hot Reload Configuration
Reload after modifying mcp-servers.json without restarting daemon:
agentic-mcp daemon reload
Response example:
✓ Configuration reloaded
Old servers: playwright_global
New servers: playwright_global, filesystem_global
Architecture
System Architecture
+-----------------------------+
| AI / CLI Layer |
| (CLI commands) |
| - agentic-mcp metadata |
| - agentic-mcp list |
| - agentic-mcp schema |
| - agentic-mcp call |
+-----------+-----------------+
| Socket (newline-delimited JSON)
v
+-----------------------------+
| MCP Daemon (Long-Running) |
| - Maintain persistent MCP |
| connections |
| - Socket communication |
| - Manage shared sessions |
| - Support Hot Reload |
+-----------+-----------------+
| MCP Protocol
v
+-----------------------------+
| MCP Servers |
| - playwright (browser) |
| - filesystem (files) |
| - github (Git) |
| - custom servers |
+-----------------------------+
Configuration
MCP Servers Configuration
Edit mcp-servers.json:
{
"servers": {
"playwright": {
"description": "Browser automation tool for web navigation, screenshots, clicks, and form filling",
"transportType": "stdio",
"command": "npx",
"args": ["@playwright/mcp@latest", "--isolated"]
}
}
}
Configuration Notes:
description(optional): Server description for AI to understand the MCP server's purpose. If not provided, Layer 1 metadata will not include this field.
Resources
- SKILL.md - Complete usage guide
- docs/AGENT_BROWSER_DESIGN_PATTERNS.md - Design patterns learned from agent-browser
- MCP Specification
- MCP TypeScript SDK
- AgentSkills.io
This is a concept validation project, feedback welcome
Questions sur Agentic MCP
Comment Agentic-MCP réduit-il la consommation de tokens MCP ?
Il charge les informations MCP en trois couches : les métadonnées du serveur, puis les listes d'outils, et enfin les schémas complets uniquement pour les outils que vous appelez réellement. Le README indique que cela permet d'économiser environ 86 % de tokens lorsqu'un serveur possède de nombreux outils mais que vous n'en utilisez que quelques-uns.
Quelles commandes agentic-mcp sont disponibles ?
Il expose des commandes CLI pour les métadonnées, la liste, le schéma et l'appel, ainsi que pour le démarrage du daemon, l'état de santé (health) et le rechargement (reload). Ces commandes correspondent aux trois couches de divulgation et à l'invocation des outils.
Comment installer et démarrer Agentic-MCP ?
Installez-le globalement via npm, puis démarrez le daemon avec la commande daemon start en utilisant un fichier de configuration. Node.js 18 ou une version ultérieure est requis.
Comment les MCP servers sont-ils configurés ?
Les serveurs sont définis dans mcp-servers.json avec une description, un type de transport, une commande et des arguments. Vous pouvez recharger le daemon après une modification pour prendre en compte les nouveaux serveurs sans avoir à redémarrer.