Version imprimable multipages. Cliquer ici pour imprimer.
Les guides pratiques sont des recettes orientées problème qui vous guident à travers les étapes impliquées dans la résolution de problèmes clés et de cas d’utilisation. Ils sont pragmatiques et orientés vers des objectifs.
Ces guides vous aideront à résoudre des tâches spécifiques et à personnaliser gomcptest pour vos besoins.
This guide shows you how to create a new custom tool that’s compatible with the Model Context Protocol (MCP) in gomcptest.
mkdir -p tools/YourToolName/cmd
Create a README.md in the tool directory with documentation:
touch tools/YourToolName/README.md
Include the following sections:
Create a main.go file in the cmd directory:
touch tools/YourToolName/cmd/main.go
Here’s a template to start with:
package main
import (
"encoding/json"
"fmt"
"log"
"os"
"github.com/mark3labs/mcp-go"
)
// Define your tool's parameters structure
type Params struct {
// Add your parameters here
// Example:
InputParam string `json:"input_param"`
}
func main() {
server := mcp.NewServer()
// Register your tool function
server.RegisterFunction("YourToolName", func(params json.RawMessage) (any, error) {
var p Params
if err := json.Unmarshal(params, &p); err != nil {
return nil, fmt.Errorf("failed to parse parameters: %w", err)
}
// Implement your tool's logic here
result := doSomethingWithParams(p)
return result, nil
})
if err := server.Run(os.Stdin, os.Stdout); err != nil {
log.Fatalf("Server error: %v", err)
}
}
func doSomethingWithParams(p Params) interface{} {
// Your tool's core functionality
// ...
// Return the result
return map[string]interface{}{
"result": "Your processed result",
}
}
Open the Makefile in the root directory and add your tool:
YourToolName:
go build -o bin/YourToolName tools/YourToolName/cmd/main.go
Also add it to the all target.
make YourToolName
Test the tool directly:
echo '{"name":"YourToolName","params":{"input_param":"test"}}' | ./bin/YourToolName
Add your tool to the CLI command:
./bin/cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./YourToolName;./dispatch_agent;./Bash;./Replace"
This guide shows you how to configure and customize the OpenAI-compatible server in gomcptest for different use cases.
The OpenAI server can be configured using the following environment variables:
# Server port (default: 8080)
export PORT=8080
# Log level: DEBUG, INFO, WARN, ERROR (default: INFO)
export LOG_LEVEL=INFO
# Directory to store images (required)
export IMAGE_DIR=/path/to/image/directory
Configure the Google Cloud Platform integration:
# GCP Project ID (required)
export GCP_PROJECT=your-gcp-project-id
# GCP Region (default: us-central1)
export GCP_REGION=us-central1
# Comma-separated list of Gemini models (default: gemini-1.5-pro,gemini-2.0-flash)
export GEMINI_MODELS=gemini-1.5-pro,gemini-2.0-flash
# Comma-separated list of Imagen models (optional)
export IMAGEN_MODELS=imagen-3.0-generate-002
For a production environment, create a proper systemd service file:
sudo nano /etc/systemd/system/gomcptest-openai.service
Add the following content:
[Unit]
Description=gomcptest OpenAI Server
After=network.target
[Service]
User=yourusername
WorkingDirectory=/path/to/gomcptest/host/openaiserver
ExecStart=/path/to/gomcptest/host/openaiserver/openaiserver -mcpservers "/path/to/gomcptest/bin/GlobTool;/path/to/gomcptest/bin/GrepTool;/path/to/gomcptest/bin/LS;/path/to/gomcptest/bin/View;/path/to/gomcptest/bin/Bash;/path/to/gomcptest/bin/Replace"
Environment=PORT=8080
Environment=LOG_LEVEL=INFO
Environment=IMAGE_DIR=/path/to/image/directory
Environment=GCP_PROJECT=your-gcp-project-id
Environment=GCP_REGION=us-central1
Environment=GEMINI_MODELS=gemini-1.5-pro,gemini-2.0-flash
Restart=on-failure
[Install]
WantedBy=multi-user.target
Then enable and start the service:
sudo systemctl enable gomcptest-openai
sudo systemctl start gomcptest-openai
To add custom MCP tools to the server, include them in the -mcpservers parameter when starting the server:
go run . -mcpservers "../bin/GlobTool;../bin/GrepTool;../bin/LS;../bin/View;../bin/YourCustomTool;../bin/Bash;../bin/Replace"
Some tools require additional parameters. You can specify these after the tool path:
go run . -mcpservers "../bin/GlobTool;../bin/dispatch_agent -glob-path ../bin/GlobTool -grep-path ../bin/GrepTool -ls-path ../bin/LS -view-path ../bin/View"
For web applications, you may need to enable CORS. Add a middleware to the main.go file:
package main
import (
"net/http"
// other imports
)
// CORS middleware
func corsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
if r.Method == "OPTIONS" {
w.WriteHeader(http.StatusOK)
return
}
next.ServeHTTP(w, r)
})
}
func main() {
// existing code...
http.Handle("/", corsMiddleware(openAIHandler))
// existing code...
}
Add a simple rate limiting middleware:
package main
import (
"net/http"
"sync"
"time"
// other imports
)
type RateLimiter struct {
requests map[string][]time.Time
maxRequests int
timeWindow time.Duration
mu sync.Mutex
}
func NewRateLimiter(maxRequests int, timeWindow time.Duration) *RateLimiter {
return &RateLimiter{
requests: make(map[string][]time.Time),
maxRequests: maxRequests,
timeWindow: timeWindow,
}
}
func (rl *RateLimiter) Middleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ip := r.RemoteAddr
rl.mu.Lock()
// Clean up old requests
now := time.Now()
if reqs, exists := rl.requests[ip]; exists {
var validReqs []time.Time
for _, req := range reqs {
if now.Sub(req) <= rl.timeWindow {
validReqs = append(validReqs, req)
}
}
rl.requests[ip] = validReqs
}
// Check if rate limit is exceeded
if len(rl.requests[ip]) >= rl.maxRequests {
rl.mu.Unlock()
http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
return
}
// Add current request
rl.requests[ip] = append(rl.requests[ip], now)
rl.mu.Unlock()
next.ServeHTTP(w, r)
})
}
func main() {
// existing code...
rateLimiter := NewRateLimiter(10, time.Minute) // 10 requests per minute
http.Handle("/", rateLimiter.Middleware(corsMiddleware(openAIHandler)))
// existing code...
}
For high-load scenarios, adjust Go’s garbage collector:
export GOGC=100 # Default is 100, lower values lead to more frequent GC
If handling many concurrent requests, adjust the server’s concurrency limits:
package main
import (
"net/http"
// other imports
)
func main() {
// existing code...
server := &http.Server{
Addr: ":" + strconv.Itoa(cfg.Port),
Handler: openAIHandler,
ReadTimeout: 30 * time.Second,
WriteTimeout: 120 * time.Second,
IdleTimeout: 120 * time.Second,
MaxHeaderBytes: 1 << 20,
}
err = server.ListenAndServe()
// existing code...
}
If you’re experiencing connection issues, set the log level to DEBUG:
export LOG_LEVEL=DEBUG
To verify tools are registered correctly, look for log messages like:
INFO server0 Registering command=../bin/GlobTool
INFO server1 Registering command=../bin/GrepTool
Ce guide vous montre comment configurer et personnaliser l’interface en ligne de commande cliGCP pour divers cas d’utilisation.
L’outil cliGCP accepte les arguments de ligne de commande suivants :
# Spécifier les serveurs MCP à utiliser (requis)
-mcpservers "outil1;outil2;outil3"
# Exemple avec des arguments d'outil
./cliGCP -mcpservers "./GlobTool;./GrepTool;./dispatch_agent -glob-path ./GlobTool -grep-path ./GrepTool -ls-path ./LS -view-path ./View;./Bash"
Configurez l’intégration avec Google Cloud Platform avec ces variables d’environnement :
# ID du projet GCP (requis)
export GCP_PROJECT=votre-id-de-projet-gcp
# Région GCP (par défaut : us-central1)
export GCP_REGION=us-central1
# Liste de modèles Gemini séparés par des virgules (requis)
export GEMINI_MODELS=gemini-1.5-pro,gemini-2.0-flash
# Répertoire pour stocker les images (requis pour la génération d'images)
export IMAGE_DIR=/chemin/vers/repertoire/images
Vous pouvez personnaliser le comportement de l’outil cliGCP avec ces variables d’environnement supplémentaires :
# Définir une instruction système personnalisée pour le modèle
export SYSTEM_INSTRUCTION="Vous êtes un assistant utile spécialisé dans la programmation Go."
# Ajuster la température du modèle (0.0-1.0, la valeur par défaut est 0.2)
# Les valeurs plus basses rendent la sortie plus déterministe, les valeurs plus élevées plus créatives
export MODEL_TEMPERATURE=0.3
# Définir une limite maximale de tokens pour les réponses
export MAX_OUTPUT_TOKENS=2048
Pour simplifier l’utilisation, créez des alias shell dans votre .bashrc ou .zshrc :
# Ajouter à ~/.bashrc ou ~/.zshrc
alias gpt='cd /chemin/vers/gomcptest/bin && ./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./Bash;./Replace"'
# Créer des alias spécialisés pour différentes tâches
alias assistant-code='cd /chemin/vers/gomcptest/bin && GCP_PROJECT=votre-projet GEMINI_MODELS=gemini-2.0-flash ./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./Bash;./Replace"'
alias scanner-securite='cd /chemin/vers/gomcptest/bin && SYSTEM_INSTRUCTION="Vous êtes un expert en sécurité concentré sur la recherche de vulnérabilités dans le code" ./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./Bash"'
Pour modifier l’instruction système par défaut, éditez le fichier agent.go :
// Dans host/cliGCP/cmd/agent.go
genaimodels[model].SystemInstruction = &genai.Content{
Role: "user",
Parts: []genai.Part{
genai.Text("Vous êtes un agent utile avec accès à des outils. " +
"Votre travail est d'aider l'utilisateur en effectuant des tâches à l'aide de ces outils. " +
"Vous ne devez pas inventer d'informations. " +
"Si vous ne savez pas quelque chose, dites-le et expliquez ce que vous auriez besoin de savoir pour aider. " +
"Si aucune indication, utilisez le répertoire de travail actuel qui est " + cwd),
},
}
Pour différents cas d’utilisation, vous pouvez créer des scripts de configuration spécialisés :
Créez un fichier appelé reviseur-code.sh :
#!/bin/bash
export GCP_PROJECT=votre-id-de-projet-gcp
export GCP_REGION=us-central1
export GEMINI_MODELS=gemini-2.0-flash
export IMAGE_DIR=/tmp/images
export SYSTEM_INSTRUCTION="Vous êtes un expert en revue de code. Analysez le code pour détecter les bugs, les problèmes de sécurité et les domaines à améliorer. Concentrez-vous sur la fourniture de commentaires constructifs et d'explications détaillées."
cd /chemin/vers/gomcptest/bin
./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./Bash"
Rendez-le exécutable :
chmod +x reviseur-code.sh
Créez un fichier appelé generateur-doc.sh :
#!/bin/bash
export GCP_PROJECT=votre-id-de-projet-gcp
export GCP_REGION=us-central1
export GEMINI_MODELS=gemini-2.0-flash
export IMAGE_DIR=/tmp/images
export SYSTEM_INSTRUCTION="Vous êtes un spécialiste de la documentation. Votre tâche est d'aider à créer une documentation claire et complète pour le code. Analysez la structure du code et créez une documentation appropriée en suivant les meilleures pratiques."
cd /chemin/vers/gomcptest/bin
./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./Bash;./Replace"
Lorsque vous utilisez l’outil dispatch_agent, vous pouvez configurer son comportement avec des arguments supplémentaires :
./cliGCP -mcpservers "./GlobTool;./GrepTool;./LS;./View;./dispatch_agent -glob-path ./GlobTool -grep-path ./GrepTool -ls-path ./LS -view-path ./View -timeout 30s;./Bash;./Replace"
Vous pouvez créer des combinaisons d’outils spécialisées pour différentes tâches :
# Ensemble d'outils pour le développement web
./cliGCP -mcpservers "./GlobTool -include '*.{html,css,js}';./GrepTool;./LS;./View;./Bash;./Replace"
# Ensemble d'outils pour le développement Go
./cliGCP -mcpservers "./GlobTool -include '*.go';./GrepTool;./LS;./View;./Bash;./Replace"
Si vous rencontrez des difficultés pour vous connecter au modèle Gemini :
gcloud auth application-default print-access-token
gcloud services list --enabled | grep aiplatform
Si les outils échouent à s’exécuter :
Pour de meilleures performances :
Ce guide vous montre comment configurer le serveur compatible OpenAI de gomcptest pour fonctionner avec big-AGI, un client web open-source populaire pour les assistants IA.
big-AGI fournit une interface web soignée et riche en fonctionnalités pour interagir avec des modèles d’IA. En le connectant au serveur compatible OpenAI de gomcptest, vous obtenez :
Cloner le dépôt big-AGI :
git clone https://github.com/enricoros/big-agi.git
cd big-agi
Installer les dépendances :
npm install
Créer un fichier .env.local pour la configuration :
cp .env.example .env.local
Éditer le fichier .env.local pour configurer la connexion à votre serveur gomcptest :
# Configuration big-AGI
# URL de votre serveur compatible OpenAI gomcptest
OPENAI_API_HOST=http://localhost:8080
# Il peut s'agir de n'importe quelle chaîne car le serveur gomcptest n'utilise pas de clés API
OPENAI_API_KEY=gomcptest-local-server
# Définissez cette valeur sur true pour activer le fournisseur personnalisé
OPENAI_API_ENABLE_CUSTOM_PROVIDER=true
Démarrer big-AGI :
npm run dev
Ouvrez votre navigateur et accédez à http://localhost:3000 pour accéder à l’interface big-AGI.
Le serveur compatible OpenAI de gomcptest expose les modèles Google Cloud via une API compatible OpenAI. Dans big-AGI, vous devrez configurer les modèles :
gemini-1.5-pro, gemini-2.0-flash)true pour les modèles qui la prennent en chargePour utiliser les outils MCP via l’interface d’appel de fonction de big-AGI :
Si vous exécutez big-AGI sur un domaine ou un port différent de celui de votre serveur gomcptest, vous devrez activer CORS côté serveur. Modifiez la configuration du serveur OpenAI :
Créez ou modifiez un middleware CORS pour le serveur OpenAI :
// Middleware CORS avec autorisation d'origine spécifique
func corsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Autoriser les requêtes provenant de l'origine big-AGI
w.Header().Set("Access-Control-Allow-Origin", "http://localhost:3000")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
if r.Method == "OPTIONS" {
w.WriteHeader(http.StatusOK)
return
}
next.ServeHTTP(w, r)
})
}
Appliquez ce middleware à vos routes de serveur
Si big-AGI signale que les modèles ne peuvent pas être trouvés :
Si les outils ne fonctionnent pas correctement :
Si big-AGI ne peut pas se connecter à votre serveur :
OPENAI_API_HOST dans votre fichier .env.localPour une utilisation en production, considérez :
Sécurisation de votre API :
OPENAI_API_KEY dans big-AGI en conséquenceDéploiement de big-AGI :
Mise en place de HTTPS :
Une fois que tout est configuré, vous pouvez utiliser l’interface de big-AGI pour interagir avec vos modèles d’IA :
gemini-1.5-pro)L’interface big-AGI offre une expérience beaucoup plus riche qu’une interface en ligne de commande, avec des fonctionnalités comme l’historique des conversations, le rendu markdown, la mise en évidence du code, et plus encore.