CODE

Génération et complétion de code avec intelligence artificielle

Introduction

L'API CODE d'AlphaEdge vous permet de générer et compléter du code. Cette fonctionnalité est optimisée pour offrir des performances élevées et une grande précision.

Cette page vous guide à travers l'utilisation de l'API CODE, depuis les bases jusqu'aux cas d'usage avancés.

Démarrage rapide

Voici un exemple minimal pour commencer avec l'API CODE :

Exemple basique

python
from alphaedge import AlphaEdge

client = AlphaEdge(api_key="votre_cle_api")

# Génération de code
response = client.code.complete(
    prompt="Crée une fonction Python pour calculer la factorielle",
    model="alphaedge-code-3"
)
print(response.code)
bash
curl https://api.alphaedge-ai.com/v1/code \
  -H "Authorization: Bearer $ALPHAEDGE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "alphaedge-code-3",
    "prompt": "Crée une fonction Python pour calculer la factorielle"
  }'
javascript
const AlphaEdge = require('@alphaedge/ai-sdk');

const client = new AlphaEdge({
  apiKey: process.env.ALPHAEDGE_API_KEY
});

// Génération de code
const response = await client.code.complete({
  prompt: 'Crée une fonction JavaScript pour calculer la factorielle',
  model: 'alphaedge-code-3'
});
console.log(response.code);

Paramètres de l'API

Voici les paramètres disponibles pour l'API CODE :

PARAMÈTRE TYPE REQUIS DÉFAUT DESCRIPTION
model string Oui - Le nom du modèle à utiliser (ex: alphaedge-code-3)
prompt string Oui - Le texte d'entrée à traiter
language string Non auto Langage de programmation cible (ex: python, javascript, java)
temperature float Non 0.7 Contrôle la créativité (0.0 = déterministe, 2.0 = très créatif)
max_tokens integer Non 2048 Nombre maximum de tokens à générer
stream boolean Non false Activer le streaming des réponses en temps réel

Formats de fichiers supportés

L'API Code d'AlphaEdge prend en charge de nombreux formats de fichiers de code source. Voici la liste complète des formats supportés :

Langages de programmation

  • Python (.py, .pyw, .pyi) - Scripts Python, modules, stubs
  • JavaScript/TypeScript (.js, .jsx, .ts, .tsx) - Code frontend et backend
  • Java (.java) - Code source Java
  • C/C++ (.c, .cpp, .cc, .cxx, .h, .hpp) - Code système et applications
  • C# (.cs) - Code .NET
  • Go (.go) - Code Go
  • Rust (.rs) - Code Rust
  • Ruby (.rb) - Scripts Ruby
  • PHP (.php) - Scripts PHP
  • Swift (.swift) - Code iOS/macOS
  • Kotlin (.kt, .kts) - Code Android/JVM
  • Scala (.scala) - Code Scala
  • R (.r, .R) - Scripts statistiques
  • MATLAB (.m) - Scripts MATLAB

Langages web et markup

  • HTML (.html, .htm) - Pages web
  • CSS (.css, .scss, .sass, .less) - Styles et feuilles de style
  • XML (.xml) - Données structurées
  • JSON (.json) - Données JSON
  • YAML (.yaml, .yml) - Configuration et données
  • Markdown (.md, .markdown) - Documentation

Langages de configuration et scripts

  • Shell/Bash (.sh, .bash, .zsh) - Scripts shell
  • PowerShell (.ps1, .psm1) - Scripts Windows
  • SQL (.sql) - Requêtes et scripts SQL
  • Dockerfile (Dockerfile, .dockerfile) - Configurations Docker
  • Makefile (Makefile, makefile) - Fichiers de build
  • INI (.ini) - Fichiers de configuration
  • TOML (.toml) - Configuration moderne

Spécifications techniques

  • Taille maximale : 1 MB par fichier (recommandé : < 500 KB)
  • Encodage : UTF-8 (recommandé), UTF-16, ASCII
  • Lignes maximales : 10 000 lignes par fichier

Recommandations

  • Pour la complétion de code : Fournissez le contexte complet du fichier
  • Pour la génération : Spécifiez clairement le langage cible
  • Pour les gros fichiers : Divisez en modules ou fonctions plus petites
  • Incluez les imports et dépendances pour un meilleur contexte

Format de réponse

L'API CODE retourne une réponse au format JSON. Voici un exemple de structure de réponse :

json
{
  "id": "req_abc123",
  "object": "code.response",
  "created": 1677652288,
  "model": "alphaedge-code-3",
  "code": "def function_name():\n    ...",
  "language": "python",
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 50,
    "total_tokens": 60
  }
}

Exemples avancés

Complétion de code avec contexte

Complétez du code en tenant compte du contexte existant :

python
response = client.code.complete(
    prompt="def calculate_total(items):\n    # TODO: implémenter la fonction",
    model="alphaedge-code-3",
    language="python",
    context="Cette fonction doit calculer la somme des prix"
)
print(response.code)

Gestion des erreurs

Voici comment gérer les erreurs de manière appropriée :

python
from alphaedge import AlphaEdge, APIError

client = AlphaEdge(api_key="votre_cle_api")

try:
    response = client.code.complete(
        prompt="Votre prompt",
        model="alphaedge-code-3"
    )
    print(response)
except APIError as e:
    print(f"Erreur API: {e.message}")
    print(f"Code: {e.code}")
except FileNotFoundError:
    print("Fichier non trouvé")
except Exception as e:
    print(f"Erreur inattendue: {e}")
javascript
const AlphaEdge = require('@alphaedge/ai-sdk');

const client = new AlphaEdge({
  apiKey: process.env.ALPHAEDGE_API_KEY
});

try {
  const response = await client.code.complete({
    prompt: 'Votre prompt',
    model: 'alphaedge-code-3'
  });
  console.log(response);
} catch (error) {
  if (error instanceof AlphaEdge.APIError) {
    console.error(`Erreur API: ${error.message}`);
    console.error(`Code: ${error.code}`);
  } else if (error.code === 'ENOENT') {
    console.error('Fichier non trouvé');
  } else {
    console.error(`Erreur inattendue: ${error.message}`);
  }
}

Cas d'usage

Voici quelques cas d'usage courants pour l'API CODE :

1. Génération de code à partir de descriptions

Générez du code fonctionnel à partir de descriptions en langage naturel.

2. Complétion intelligente

Améliorez votre productivité avec des suggestions de code contextuelles.

3. Refactoring automatique

Améliorez et optimisez votre code existant automatiquement.

Limitations et bonnes pratiques

Limitations

  • Taille de fichier : Les fichiers ne doivent pas dépasser 1 MB (recommandé : < 500 KB)
  • Formats supportés : Tous les langages de programmation courants (Python, JavaScript, Java, C/C++, Go, Rust, Ruby, PHP, Swift, Kotlin, Scala, R, MATLAB, HTML, CSS, XML, JSON, YAML, Markdown, Shell, PowerShell, SQL, Dockerfile, Makefile, INI, TOML)
  • Lignes maximales : 10 000 lignes par fichier
  • Rate limiting : 60 requêtes par minute par défaut (peut être augmenté selon votre plan)
  • Tokens : Limite de 4096 tokens pour les prompts et réponses combinés
  • Pages PDF : Maximum 100 pages par document

Bonnes pratiques

  • Fournissez le contexte complet du fichier pour la complétion de code
  • Spécifiez clairement le langage cible pour la génération
  • Gérez les erreurs de manière appropriée avec des try/except
  • Implémentez un système de retry pour gérer les erreurs temporaires
  • Cachez les résultats lorsque c'est possible pour réduire les coûts
  • Surveillez votre utilisation pour éviter de dépasser vos limites

Modèles disponibles

Pour voir tous les modèles CODE disponibles avec leurs spécifications détaillées, consultez la page Nos modèles et filtrez par type.