MCP-CLI : Outil d'interface en ligne de commande pour le protocole de contexte de modèle

Aperçu du projet

MCP-CLI est un outil d'interface en ligne de commande puissant et riche en fonctionnalités, spécialement conçu pour interagir avec les serveurs du Protocole de Contexte de Modèle (Model Context Protocol, MCP). Cet outil, en intégrant la bibliothèque de protocole CHUK-MCP, offre aux utilisateurs une capacité de communication transparente avec les Grands Modèles Linguistiques (LLM).

Ce client prend en charge l'utilisation d'outils, la gestion des conversations et plusieurs modes de fonctionnement. L'implémentation du protocole central a été migrée vers un paquet séparé, ce qui permet au CLI de se concentrer sur l'offre d'une expérience utilisateur riche, tandis que la bibliothèque de protocole gère la couche de communication.

Caractéristiques principales

🔄 Plusieurs modes de fonctionnement

• Mode Chat (Chat Mode) : Interface conversationnelle, prenant en charge l'interaction directe avec le LLM et l'utilisation automatisée d'outils.
• Mode Interactif (Interactive Mode) : Interface pilotée par des commandes, pour des opérations directes sur le serveur.
• Mode Commande (Command Mode) : Mode convivial pour Unix, prenant en charge l'automatisation scriptée et les opérations de pipeline.
• Commandes Directes : Exécuter une seule commande sans entrer en mode interactif.

🌐 Prise en charge multi-fournisseurs

• Intégration OpenAI : Prend en charge les modèles gpt-4o-mini, gpt-4o, gpt-4-turbo, etc.
• Intégration Ollama : Prend en charge les modèles locaux llama3.2, qwen2.5-coder, etc.
• Architecture Extensible : Prend en charge l'ajout d'autres fournisseurs.

🛠️ Système d'outils puissant

• Découverte automatique des outils fournis par le serveur.
• Exécution d'outils consciente du serveur.
• Suivi et analyse de l'historique des appels d'outils.
• Prise en charge des chaînes d'outils complexes à plusieurs étapes.

💬 Gestion avancée des conversations

• Suivi complet de l'historique des conversations.
• Prise en charge du filtrage et de la visualisation de plages de messages spécifiques.
• Fonctionnalité d'exportation JSON, pour le débogage ou l'analyse.
• Fonctionnalité de compression de conversation, réduisant l'utilisation des tokens.

🎨 Expérience utilisateur riche

• Auto-complétion de commandes sensible au contexte.
• Sortie console formatée en couleur.
• Indicateurs de progression pour les opérations de longue durée.
• Aide et documentation détaillées.

🔧 Gestion fiable des ressources

• Nettoyage approprié des ressources d'E/S asynchrones.
• Gestion élégante des erreurs.
• Restauration propre du terminal.
• Prise en charge de plusieurs connexions serveur simultanées.

Configuration requise

• Python 3.11 ou supérieur
• Pour OpenAI : Une clé API valide doit être définie dans la variable d'environnement OPENAI_API_KEY.
• Pour Ollama : Une installation locale d'Ollama est requise.
• Fichier de configuration du serveur (par défaut : server_config.json)
• Bibliothèque de protocole CHUK-MCP

Méthodes d'installation

Installation Standard

# Cloner le dépôt
git clone https://github.com/chrishayuk/mcp-cli
cd mcp-cli

# Installer le paquet et les dépendances de développement
pip install -e ".[cli,dev]"

# Exécuter le CLI
mcp-cli --help

Utilisation de UV pour la gestion des dépendances

# Installer UV (si non déjà installé)
pip install uv

# Installer les dépendances
uv sync --reinstall

# Exécuter avec UV
uv run mcp-cli --help

Guide d'utilisation

Options Globales

Toutes les commandes prennent en charge les options globales suivantes :

• --server : Spécifier le(s) serveur(s) à connecter (plusieurs serveurs séparés par des virgules).
• --config-file : Chemin du fichier de configuration du serveur (par défaut : server_config.json).
• --provider : Fournisseur LLM à utiliser (openai ou ollama, par défaut : openai).
• --model : Modèle spécifique à utiliser (dépend des valeurs par défaut du fournisseur).
• --disable-filesystem : Désactiver l'accès au système de fichiers (par défaut : true).

Mode Chat

Le mode chat offre une interface conversationnelle avec le LLM, utilisant automatiquement les outils disponibles si nécessaire :

# Mode chat basique
mcp-cli chat --server sqlite

# Spécifier le fournisseur et le modèle
mcp-cli chat --server sqlite --provider openai --model gpt-4o
mcp-cli chat --server sqlite --provider ollama --model llama3.2

Commandes Slash du Mode Chat

En mode chat, les commandes slash suivantes peuvent être utilisées :

Commandes d'Aide :

• /help : Afficher les commandes disponibles.
• /help <command> : Afficher l'aide détaillée pour une commande spécifique.
• /quickhelp ou /qh : Afficher une référence rapide pour les commandes courantes.

Lié aux Outils :

• /tools : Afficher tous les outils disponibles et leurs informations de serveur.
• /tools --all : Afficher les informations détaillées des outils, y compris les paramètres.
• /tools --raw : Afficher les définitions brutes des outils.
• /toolhistory ou /th : Afficher l'historique des appels d'outils pour la session actuelle.

Gestion des Conversations :

• /conversation ou /ch : Afficher l'historique de la conversation.
• /save <filename> : Enregistrer l'historique de la conversation dans un fichier JSON.
• /compact : Compacter l'historique de la conversation en un résumé.

Contrôle de l'Interface :

• /cls : Effacer l'écran mais conserver l'historique de la conversation.
• /clear : Effacer l'écran et l'historique de la conversation.
• /verbose ou /v : Basculer entre les modes d'affichage d'outils verbeux et concis.

Mode Interactif

Le mode interactif offre une interface en ligne de commande, utilisant des commandes slash pour une interaction directe avec le serveur :

mcp-cli interactive --server sqlite

Commandes du Mode Interactif

• /ping : Vérifier si le serveur répond.
• /prompts : Lister les invites disponibles.
• /tools : Lister les outils disponibles.
• /resources : Lister les ressources disponibles.
• /chat : Entrer en mode chat.
• /exit ou /quit : Quitter le programme.

Mode Commande

Le mode commande offre une interface conviviale pour Unix, pour l'automatisation et l'intégration de pipelines :

mcp-cli cmd --server sqlite [options]

Options du Mode Commande

• --input : Chemin du fichier d'entrée (utiliser - pour l'entrée standard).
• --output : Chemin du fichier de sortie (utiliser - pour la sortie standard, par défaut).
• --prompt : Modèle d'invite (utiliser {{input}} comme espace réservé pour l'entrée).
• --raw : Afficher le texte brut sans formatage.
• --tool : Appeler directement un outil spécifique.
• --tool-args : Paramètres JSON pour l'appel d'outil.
• --system-prompt : Invite système personnalisée.

Exemples du Mode Commande

# Résumer un document
mcp-cli cmd --server sqlite --input document.md --prompt "Résumez ceci : {{input}}" --output summary.md

# Traiter l'entrée standard et sortir vers la sortie standard
cat document.md | mcp-cli cmd --server sqlite --input - --prompt "Extrayez les points clés : {{input}}"

# Appeler directement un outil
mcp-cli cmd --server sqlite --tool list_tables --raw
mcp-cli cmd --server sqlite --tool read_query --tool-args '{"query": "SELECT COUNT(*) FROM users"}'

# Traitement par lots
ls *.md | parallel mcp-cli cmd --server sqlite --input {} --output {}.summary.md --prompt "Résumez : {{input}}"

Commandes Directes

Exécuter une seule commande sans entrer en mode interactif :

# Lister les outils disponibles
mcp-cli tools list --server sqlite

# Appeler un outil spécifique
mcp-cli tools call --server sqlite

# Lister les invites disponibles
mcp-cli prompts list --server sqlite

# Vérifier la connexion au serveur
mcp-cli ping --server sqlite

# Lister les ressources disponibles
mcp-cli resources list --server sqlite

Fichier de configuration

Créez un fichier server_config.json pour configurer les serveurs :

{
  "mcpServers": {
    "sqlite": {
      "command": "python",
      "args": ["-m", "mcp_server.sqlite_server"],
      "env": {
        "DATABASE_PATH": "your_database.db"
      }
    },
    "another-server": {
      "command": "python",
      "args": ["-m", "another_server_module"],
      "env": {}
    }
  }
}

Structure du projet

src/
├── mcp_cli/
│   ├── chat/                    # Implémentation du mode chat
│   │   ├── commands/            # Commandes slash du chat
│   │   │   ├── __init__.py      # Système d'enregistrement des commandes
│   │   │   ├── conversation.py  # Gestion des conversations
│   │   │   ├── help.py          # Commandes d'aide
│   │   │   ├── tools.py         # Commandes d'outils
│   │   │   └── ...
│   │   ├── chat_context.py      # Gestion de l'état de la session de chat
│   │   ├── chat_handler.py      # Gestionnaire de la boucle de chat principale
│   │   ├── command_completer.py # Auto-complétion des commandes
│   │   └── ui_manager.py        # Interface utilisateur
│   ├── commands/                # Commandes CLI
│   │   ├── chat.py              # Commande chat
│   │   ├── cmd.py               # Mode commande
│   │   ├── interactive.py       # Mode interactif
│   │   └── ...
│   ├── llm/                     # Implémentation du client LLM
│   │   ├── providers/           # Clients spécifiques aux fournisseurs
│   │   │   ├── base.py          # Client LLM de base
│   │   │   └── openai_client.py # Implémentation OpenAI
│   │   └── llm_client.py        # Fabrique de clients
│   ├── ui/                      # Composants de l'Interface Utilisateur
│   │   ├── colors.py            # Définitions de couleurs
│   │   └── ui_helpers.py        # Utilitaires d'interface utilisateur
│   ├── main.py                  # Point d'entrée principal
│   └── config.py                # Chargeur de configuration

Exemples d'utilisation

Exécution automatique d'outils

En mode chat, MCP CLI peut exécuter automatiquement les outils fournis par le serveur :

You: What tables are available in the database?
Assistant: Let me check for you.
[Tool Call: list_tables]
I found the following tables in the database:
- users
- products  
- orders
- categories

You: How many users do we have?
Assistant: I'll query the database for that information.
[Tool Call: read_query]
There are 873 users in the database.

Traduction du dialogue :

Vous : Quelles tables sont disponibles dans la base de données ?
Assistant : Laissez-moi vérifier pour vous.
[Appel d'outil : list_tables]
J'ai trouvé les tables suivantes dans la base de données :
- users
- products  
- orders
- categories

Vous : Combien d'utilisateurs avons-nous ?
Assistant : Je vais interroger la base de données pour cette information.
[Appel d'outil : read_query]
Il y a 873 utilisateurs dans la base de données.

Scripting automatisé

Le mode commande prend en charge de puissants scripts d'automatisation :

#!/bin/bash
# Exemple de script pour analyser plusieurs documents

# Traiter tous les fichiers markdown dans le répertoire actuel
for file in *.md; do
    echo "Processing $file..."
    
    # Générer un résumé
    mcp-cli cmd --server sqlite --input "$file" \
        --prompt "Summarize this document: {{input}}" \
        --output "${file%.md}.summary.md"
    
    # Extraire les entités
    mcp-cli cmd --server sqlite --input "$file" \
        --prompt "Extract all company names, people, and locations from this text: {{input}}" \
        --output "${file%.md}.entities.txt" --raw
done

# Créer un rapport complet
echo "Creating final report..."
cat *.entities.txt | mcp-cli cmd --server sqlite --input - \
    --prompt "Analyze these entities and identify the most frequently mentioned:" \
    --output report.md

Traduction des commentaires du script :

#!/bin/bash
# Exemple de script pour analyser plusieurs documents

# Traiter tous les fichiers markdown dans le répertoire actuel
for file in *.md; do
    echo "Traitement de $file..."
    
    # Générer un résumé
    mcp-cli cmd --server sqlite --input "$file" \
        --prompt "Résumez ce document : {{input}}" \
        --output "${file%.md}.summary.md"
    
    # Extraire les entités
    mcp-cli cmd --server sqlite --input "$file" \
        --prompt "Extrayez tous les noms d'entreprise, personnes et lieux de ce texte : {{input}}" \
        --output "${file%.md}.entities.txt" --raw
done

# Créer un rapport final
echo "Création du rapport final..."
cat *.entities.txt | mcp-cli cmd --server sqlite --input - \
    --prompt "Analysez ces entités et identifiez les plus fréquemment mentionnées :" \
    --output report.md

Gestion de l'historique des conversations

Suivre et gérer l'historique des conversations :

> /conversation
Conversation History (12 messages)
# | Role | Content
1 | system | You are an intelligent assistant capable of using t...
2 | user | What tables are available in the database?
3 | assistant | Let me check for you.
4 | assistant | [Tool call: list_tables]
...

> /conversation 4
Message #4 (Role: assistant)
[Tool call: list_tables]
Tool Calls:
1. ID: call_list_tables_12345678, Type: function, Name: list_tables
Arguments: {}

> /save conversation.json
Conversation saved to conversation.json

> /compact
Conversation history compacted with summary.
Summary:
The user asked about database tables, and I listed the available tables (users, products, orders, categories). The user then asked about the number of users, and I queried the database to find there are 873 users.

Traduction du dialogue :

> /conversation
Historique de la conversation (12 messages)
# | Rôle | Contenu
1 | system | Vous êtes un assistant intelligent capable d'utiliser d...
2 | user | Quelles tables sont disponibles dans la base de données ?
3 | assistant | Laissez-moi vérifier pour vous.
4 | assistant | [Appel d'outil : list_tables]
...

> /conversation 4
Message #4 (Rôle : assistant)
[Appel d'outil : list_tables]
Appels d'outils :
1. ID : call_list_tables_12345678, Type : function, Nom : list_tables
Arguments : {}

> /save conversation.json
Conversation enregistrée dans conversation.json

> /compact
Historique de la conversation compacté avec un résumé.
Résumé :
L'utilisateur a posé des questions sur les tables de la base de données, et j'ai listé les tables disponibles (utilisateurs, produits, commandes, catégories). L'utilisateur a ensuite demandé le nombre d'utilisateurs, et j'ai interrogé la base de données pour trouver qu'il y a 873 utilisateurs.

Gestion des dépendances

Le CLI utilise des groupes de dépendances optionnels pour l'organisation :

• cli : Interface utilisateur de terminal riche, auto-complétion des commandes et intégrations de fournisseurs.
• dev : Outils de développement et de test.
• wasm : (Réservé pour le futur support WebAssembly).
• chuk-mcp : Bibliothèque d'implémentation du protocole (dépendance principale).

Installer des extras spécifiques :

pip install "mcp-cli[cli]"        # Fonctionnalités CLI de base
pip install "mcp-cli[cli,dev]"    # CLI + outils de développement

Guide de contribution

Contributions bienvenues ! Veuillez suivre ces étapes :

1. Forker le dépôt.
2. Créer votre branche de fonctionnalité (git checkout -b feature/amazing-feature).
3. Committer vos changements (git commit -m 'Ajouter une fonctionnalité incroyable').
4. Pousser vers la branche (git push origin feature/amazing-feature).
5. Ouvrir une Pull Request.

À propos du Protocole de Contexte de Modèle (MCP)

MCP est un protocole ouvert qui standardise la manière dont les applications fournissent du contexte aux LLM. Considérez MCP comme le port USB-C pour les applications d'IA. Tout comme l'USB-C offre un moyen standardisé de connecter des appareils à divers périphériques et accessoires, MCP offre un moyen standardisé de connecter des modèles d'IA à diverses sources de données et outils.