Comment utiliser des modèles personnalisés dans Cursor

Ce guide explique comment intégrer et utiliser des modèles d'IA personnalisés dans Cursor, vous permettant de tirer parti de différentes capacités d'IA pour votre flux de travail de développement.

Types de modèles pris en charge

Cursor prend en charge diverses intégrations de modèles d'IA :

1. Modèles compatibles OpenAI

   • Anthropic Claude
   • DeepSeek
   • Mistral
   • LLMs locaux

2. Points de terminaison API personnalisés

   • Modèles auto-hébergés
   • Services API cloud
   • Implémentations personnalisées

Configuration de base

Configuration des modèles personnalisés

1. Ouvrez les paramètres de Cursor
2. Accédez à la section Modèles d'IA
3. Ajoutez une nouvelle configuration de modèle :

{
  "models": {
    "custom-model": {
      "name": "Nom de votre modèle",
      "apiKey": "votre-clé-api",
      "baseUrl": "https://api.votre-point-terminaison.com/v1",
      "contextLength": 8192,
      "temperature": 0.7
    }
  }
}

Paramètres de configuration

Paramètre	Description	Par défaut
name	Nom d'affichage du modèle	Requis
apiKey	Clé d'authentification API	Requis
baseUrl	URL du point de terminaison API	Requis
contextLength	Fenêtre de contexte maximale	4096
temperature	Aléatoire des réponses	0.7

Intégration des modèles

Modèles compatibles OpenAI

{
  "models": {
    "custom-gpt": {
      "name": "GPT personnalisé",
      "apiKey": "${OPENAI_API_KEY}",
      "baseUrl": "https://api.openai.com/v1",
      "model": "gpt-4",
      "contextLength": 8192
    }
  }
}

Configuration Anthropic Claude

{
  "models": {
    "claude": {
      "name": "Claude",
      "apiKey": "${ANTHROPIC_API_KEY}",
      "baseUrl": "https://api.anthropic.com/v1",
      "model": "claude-2",
      "contextLength": 100000
    }
  }
}

Configuration du modèle local

{
  "models": {
    "local-llm": {
      "name": "LLM local",
      "baseUrl": "http://localhost:8000",
      "contextLength": 4096,
      "useDocker": true
    }
  }
}

Paramètres avancés

Comportement du modèle

Configurez le comportement du modèle :

{
  "models": {
    "custom-model": {
      "settings": {
        "temperature": 0.7,
        "topP": 0.9,
        "frequencyPenalty": 0.0,
        "presencePenalty": 0.0,
        "stopSequences": ["```", "###"]
      }
    }
  }
}

Formatage des réponses

{
  "models": {
    "custom-model": {
      "formatting": {
        "trimWhitespace": true,
        "removeNewlines": false,
        "maxTokens": 1000
      }
    }
  }
}

Fonctionnalités spécifiques au modèle

Complétion de code

{
  "models": {
    "code-model": {
      "features": {
        "codeCompletion": true,
        "contextAware": true,
        "multiFile": true
      }
    }
  }
}

Capacités de chat

{
  "models": {
    "chat-model": {
      "features": {
        "chat": true,
        "systemPrompts": true,
        "streaming": true
      }
    }
  }
}

Optimisation des performances

Paramètres de cache

{
  "models": {
    "custom-model": {
      "cache": {
        "enabled": true,
        "maxSize": "1GB",
        "ttl": 3600
      }
    }
  }
}

Limitation du débit

{
  "models": {
    "custom-model": {
      "rateLimit": {
        "requestsPerMinute": 60,
        "tokensPerMinute": 90000,
        "concurrent": 5
      }
    }
  }
}

Dépannage

Problèmes courants

1. Problèmes de connexion

   • Vérifier le point de terminaison API
   • Vérifier la connectivité réseau
   • Valider la clé API

2. Erreurs de réponse

   • Vérifier la compatibilité du modèle
   • Vérifier le format de la requête
   • Examiner les messages d'erreur

3. Problèmes de performance

   • Optimiser la longueur du contexte
   • Ajuster les paramètres de cache
   • Surveiller les limites de débit

Meilleures pratiques

Sécurité

1. Gestion des clés API

   • Utiliser des variables d'environnement
   • Faire tourner les clés régulièrement
   • Implémenter des contrôles d'accès

2. Validation des requêtes

   • Nettoyer les entrées
   • Valider les réponses
   • Gérer les erreurs avec élégance

Performance

1. Optimisation du contexte

   • Minimiser la taille du contexte
   • Prioriser les informations pertinentes
   • Utiliser le cache efficacement

2. Gestion des ressources

   • Limiter les requêtes parallèles
   • Surveiller l'utilisation de la mémoire
   • Optimiser les temps de réponse