1080 lines
24 KiB
Markdown
1080 lines
24 KiB
Markdown
# Guide complet : IA locale pour le code sur Windows WSL
|
|
|
|
Guide d'installation d'une IA locale performante orientée développement sur Windows avec WSL2 et GPU NVIDIA.
|
|
|
|
## Prérequis
|
|
|
|
- Windows 10/11 (version 21H2 ou supérieure)
|
|
- Carte graphique NVIDIA avec 8GB+ VRAM
|
|
- WSL2 installé
|
|
- Au moins 50GB d'espace disque libre
|
|
|
|
---
|
|
|
|
## Étape 1 : Configuration WSL2 avec support GPU
|
|
|
|
### 1.1 Installer/Mettre à jour WSL2
|
|
|
|
Ouvrir PowerShell en **administrateur** :
|
|
|
|
```powershell
|
|
# Installer WSL2 avec Ubuntu
|
|
wsl --install -d Ubuntu-22.04
|
|
|
|
# Ou mettre à jour WSL si déjà installé
|
|
wsl --update
|
|
```
|
|
|
|
Redémarrer si nécessaire, puis lancer Ubuntu depuis le menu démarrer.
|
|
|
|
### 1.2 Installer les drivers NVIDIA pour WSL
|
|
|
|
**Sur Windows** (pas dans WSL) :
|
|
|
|
1. Télécharger les derniers drivers NVIDIA : https://www.nvidia.com/Download/index.aspx
|
|
2. Installer normalement sur Windows
|
|
3. Les drivers WSL sont inclus automatiquement
|
|
|
|
**Vérification dans WSL** :
|
|
|
|
```bash
|
|
# Lancer WSL Ubuntu
|
|
wsl
|
|
|
|
# Vérifier que le GPU est détecté
|
|
nvidia-smi
|
|
```
|
|
|
|
Tu devrais voir ton GPU et la version CUDA.
|
|
|
|
### 1.3 Configurer WSL pour plus de RAM
|
|
|
|
Créer/éditer le fichier `.wslconfig` dans Windows :
|
|
|
|
**Sur Windows**, créer `C:\Users\VOTRE_NOM\.wslconfig` :
|
|
|
|
```ini
|
|
[wsl2]
|
|
memory=16GB
|
|
processors=8
|
|
swap=8GB
|
|
localhostForwarding=true
|
|
|
|
[experimental]
|
|
sparseVhd=true
|
|
```
|
|
|
|
Redémarrer WSL :
|
|
|
|
```powershell
|
|
wsl --shutdown
|
|
wsl
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 2 : Installation de Docker dans WSL
|
|
|
|
```bash
|
|
# Mise à jour du système
|
|
sudo apt update && sudo apt upgrade -y
|
|
|
|
# Installer les dépendances
|
|
sudo apt install -y \
|
|
ca-certificates \
|
|
curl \
|
|
gnupg \
|
|
lsb-release
|
|
|
|
# Ajouter le repository Docker
|
|
sudo mkdir -p /etc/apt/keyrings
|
|
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
|
|
|
|
echo \
|
|
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
|
|
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
|
|
|
|
# Installer Docker
|
|
sudo apt update
|
|
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
|
|
|
|
# Ajouter votre user au groupe docker
|
|
sudo usermod -aG docker $USER
|
|
|
|
# Activer Docker au démarrage
|
|
sudo systemctl enable docker
|
|
sudo systemctl start docker
|
|
|
|
# IMPORTANT : Se déconnecter et reconnecter pour appliquer les permissions
|
|
exit
|
|
```
|
|
|
|
Relancer WSL et vérifier :
|
|
|
|
```bash
|
|
docker --version
|
|
docker run hello-world
|
|
```
|
|
|
|
### 2.1 Installer NVIDIA Container Toolkit
|
|
|
|
```bash
|
|
# Ajouter le repository NVIDIA
|
|
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
|
|
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
|
|
|
|
curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
|
|
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
|
|
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
|
|
|
|
# Installer le toolkit
|
|
sudo apt update
|
|
sudo apt install -y nvidia-container-toolkit
|
|
|
|
# Configurer Docker pour utiliser le GPU
|
|
sudo nvidia-ctk runtime configure --runtime=docker
|
|
sudo systemctl restart docker
|
|
|
|
# Tester le GPU dans Docker
|
|
docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 3 : Installer Ollama
|
|
|
|
```bash
|
|
# Télécharger et installer Ollama
|
|
curl -fsSL https://ollama.com/install.sh | sh
|
|
|
|
# Démarrer le service Ollama
|
|
ollama serve &
|
|
|
|
# Attendre 5 secondes que le serveur démarre
|
|
sleep 5
|
|
|
|
# Vérifier que Ollama fonctionne
|
|
ollama list
|
|
```
|
|
|
|
### 3.1 Télécharger les modèles optimisés pour le code
|
|
|
|
```bash
|
|
# Qwen2.5 Coder - Le meilleur rapport qualité/vitesse
|
|
ollama pull qwen2.5-coder:7b
|
|
|
|
# DeepSeek Coder V2 - Excellente qualité (plus lourd)
|
|
ollama pull deepseek-coder-v2:16b
|
|
|
|
# Llama 3.1 - Bon généraliste
|
|
ollama pull llama3.1:8b
|
|
|
|
# Modèle d'embeddings pour le RAG
|
|
ollama pull nomic-embed-text
|
|
```
|
|
|
|
### 3.2 Tester un modèle
|
|
|
|
```bash
|
|
# Test simple
|
|
ollama run qwen2.5-coder:7b "Écris une fonction Python pour calculer Fibonacci"
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 4 : Installer Open WebUI avec support GPU
|
|
|
|
```bash
|
|
# Lancer Open WebUI avec GPU NVIDIA
|
|
docker run -d \
|
|
--gpus all \
|
|
-p 3000:8080 \
|
|
--add-host=host.docker.internal:host-gateway \
|
|
-v open-webui:/app/backend/data \
|
|
--name open-webui \
|
|
--restart always \
|
|
ghcr.io/open-webui/open-webui:cuda
|
|
|
|
# Vérifier que le container tourne
|
|
docker ps
|
|
|
|
# Voir les logs
|
|
docker logs open-webui
|
|
```
|
|
|
|
**Accéder à l'interface** :
|
|
- Ouvrir navigateur Windows : `http://localhost:3000`
|
|
- Créer un compte (local, pas de cloud)
|
|
- Les modèles Ollama seront détectés automatiquement
|
|
|
|
---
|
|
|
|
## Étape 5 : Créer des modèles personnalisés pour le code
|
|
|
|
### 5.1 Créer un Modelfile pour assistant code
|
|
|
|
```bash
|
|
# Créer un dossier pour les modelfiles
|
|
mkdir -p ~/ollama-models
|
|
cd ~/ollama-models
|
|
|
|
# Créer le fichier
|
|
cat > CodeExpert.modelfile << 'EOF'
|
|
FROM qwen2.5-coder:7b
|
|
|
|
PARAMETER temperature 0.2
|
|
PARAMETER top_p 0.95
|
|
PARAMETER top_k 40
|
|
PARAMETER num_ctx 8192
|
|
PARAMETER repeat_penalty 1.1
|
|
|
|
SYSTEM """
|
|
Tu es un expert en développement logiciel avec 15 ans d'expérience.
|
|
|
|
RÈGLES :
|
|
- Écris du code propre, lisible et maintenable
|
|
- Inclus la gestion d'erreurs appropriée
|
|
- Ajoute des commentaires pour la logique complexe
|
|
- Suis les conventions du langage utilisé
|
|
- Propose des optimisations quand pertinent
|
|
- Utilise les design patterns appropriés
|
|
- Format : markdown avec syntax highlighting
|
|
|
|
LANGAGES MAÎTRISÉS :
|
|
Python, JavaScript/TypeScript, Java, C++, Go, Rust, SQL, Shell
|
|
|
|
SPÉCIALITÉS :
|
|
- Architecture logicielle
|
|
- Optimisation de performance
|
|
- Sécurité applicative
|
|
- Tests unitaires
|
|
- Clean Code
|
|
"""
|
|
|
|
TEMPLATE """{{ if .System }}<|im_start|>system
|
|
{{ .System }}<|im_end|>
|
|
{{ end }}{{ if .Prompt }}<|im_start|>user
|
|
{{ .Prompt }}<|im_end|>
|
|
{{ end }}<|im_start|>assistant
|
|
"""
|
|
EOF
|
|
|
|
# Créer le modèle custom
|
|
ollama create code-expert -f CodeExpert.modelfile
|
|
|
|
# Tester
|
|
ollama run code-expert "Crée une API REST avec FastAPI pour gérer des utilisateurs"
|
|
```
|
|
|
|
### 5.2 Modelfile pour code review
|
|
|
|
```bash
|
|
cat > CodeReviewer.modelfile << 'EOF'
|
|
FROM qwen2.5-coder:7b
|
|
|
|
PARAMETER temperature 0.1
|
|
PARAMETER top_p 0.9
|
|
PARAMETER num_ctx 8192
|
|
|
|
SYSTEM """
|
|
Tu es un expert en code review avec un œil pour les détails.
|
|
|
|
ANALYSE :
|
|
1. 🐛 BUGS : Erreurs logiques, edge cases non gérés
|
|
2. 🔒 SÉCURITÉ : Injections SQL, XSS, secrets exposés
|
|
3. ⚡ PERFORMANCE : Complexité algorithmique, optimisations
|
|
4. 📖 LISIBILITÉ : Nommage, structure, commentaires
|
|
5. ✅ BEST PRACTICES : Patterns, conventions, maintenabilité
|
|
|
|
FORMAT :
|
|
- Liste les problèmes par ordre de priorité
|
|
- Donne des suggestions concrètes
|
|
- Indique le niveau : CRITIQUE / IMPORTANT / SUGGESTION
|
|
"""
|
|
EOF
|
|
|
|
ollama create code-reviewer -f CodeReviewer.modelfile
|
|
```
|
|
|
|
### 5.3 Modelfile pour debugging
|
|
|
|
```bash
|
|
cat > Debugger.modelfile << 'EOF'
|
|
FROM deepseek-coder-v2:16b
|
|
|
|
PARAMETER temperature 0.1
|
|
PARAMETER top_p 0.95
|
|
PARAMETER num_ctx 16384
|
|
|
|
SYSTEM """
|
|
Tu es un expert en debugging et résolution de problèmes.
|
|
|
|
MÉTHODOLOGIE :
|
|
1. Analyse le code et l'erreur fournie
|
|
2. Identifie la cause racine
|
|
3. Explique pourquoi le bug se produit
|
|
4. Propose une correction avec explication
|
|
5. Suggère des tests pour éviter la régression
|
|
|
|
FOCUS :
|
|
- Stack traces
|
|
- Erreurs runtime
|
|
- Memory leaks
|
|
- Race conditions
|
|
- Edge cases
|
|
"""
|
|
EOF
|
|
|
|
ollama create debugger -f Debugger.modelfile
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 6 : Configuration VS Code avec Continue.dev
|
|
|
|
### 6.1 Installer VS Code (si pas déjà fait)
|
|
|
|
Sur Windows, télécharger depuis : https://code.visualstudio.com/
|
|
|
|
### 6.2 Installer l'extension WSL
|
|
|
|
Dans VS Code :
|
|
1. Extensions (Ctrl+Shift+X)
|
|
2. Chercher "WSL"
|
|
3. Installer "WSL" par Microsoft
|
|
|
|
### 6.3 Se connecter à WSL
|
|
|
|
1. `Ctrl+Shift+P` → "WSL: Connect to WSL"
|
|
2. Ou cliquer sur le bouton vert en bas à gauche → "Connect to WSL"
|
|
|
|
### 6.4 Installer Continue.dev
|
|
|
|
Dans VS Code (connecté à WSL) :
|
|
1. Extensions → Chercher "Continue"
|
|
2. Installer "Continue - Codestral, Claude, and more"
|
|
|
|
### 6.5 Configurer Continue
|
|
|
|
Créer le fichier de config :
|
|
|
|
```bash
|
|
mkdir -p ~/.continue
|
|
cat > ~/.continue/config.json << 'EOF'
|
|
{
|
|
"models": [
|
|
{
|
|
"title": "Code Expert",
|
|
"provider": "ollama",
|
|
"model": "code-expert",
|
|
"apiBase": "http://localhost:11434"
|
|
},
|
|
{
|
|
"title": "Qwen Coder",
|
|
"provider": "ollama",
|
|
"model": "qwen2.5-coder:7b",
|
|
"apiBase": "http://localhost:11434"
|
|
},
|
|
{
|
|
"title": "DeepSeek Coder",
|
|
"provider": "ollama",
|
|
"model": "deepseek-coder-v2:16b",
|
|
"apiBase": "http://localhost:11434"
|
|
}
|
|
],
|
|
"tabAutocompleteModel": {
|
|
"title": "Qwen Fast Autocomplete",
|
|
"provider": "ollama",
|
|
"model": "qwen2.5-coder:7b",
|
|
"apiBase": "http://localhost:11434"
|
|
},
|
|
"embeddingsProvider": {
|
|
"provider": "ollama",
|
|
"model": "nomic-embed-text",
|
|
"apiBase": "http://localhost:11434"
|
|
},
|
|
"contextProviders": [
|
|
{
|
|
"name": "code",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "docs",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "diff",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "terminal",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "problems",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "folder",
|
|
"params": {}
|
|
},
|
|
{
|
|
"name": "codebase",
|
|
"params": {}
|
|
}
|
|
],
|
|
"slashCommands": [
|
|
{
|
|
"name": "edit",
|
|
"description": "Edit selected code"
|
|
},
|
|
{
|
|
"name": "comment",
|
|
"description": "Write comments for selected code"
|
|
},
|
|
{
|
|
"name": "share",
|
|
"description": "Export conversation to markdown"
|
|
},
|
|
{
|
|
"name": "cmd",
|
|
"description": "Generate shell command"
|
|
}
|
|
]
|
|
}
|
|
EOF
|
|
```
|
|
|
|
### 6.6 Utiliser Continue dans VS Code
|
|
|
|
**Raccourcis clavier** :
|
|
- `Ctrl+L` : Ouvrir le chat Continue
|
|
- `Ctrl+I` : Edit inline (modifier le code sélectionné)
|
|
- `Ctrl+Shift+L` : Nouveau chat
|
|
|
|
**Commandes slash** :
|
|
- `/edit` : Modifier le code sélectionné
|
|
- `/comment` : Ajouter des commentaires
|
|
- `/fix` : Corriger les erreurs
|
|
- `/test` : Générer des tests
|
|
|
|
---
|
|
|
|
## Étape 7 : Optimisations avancées
|
|
|
|
### 7.1 Script de démarrage automatique
|
|
|
|
```bash
|
|
cat > ~/start-ai-stack.sh << 'EOF'
|
|
#!/bin/bash
|
|
|
|
echo "🚀 Démarrage de la stack IA..."
|
|
|
|
# Démarrer Ollama en arrière-plan
|
|
echo "📦 Démarrage Ollama..."
|
|
ollama serve > /dev/null 2>&1 &
|
|
sleep 3
|
|
|
|
# Vérifier que Ollama tourne
|
|
if curl -s http://localhost:11434/api/tags > /dev/null; then
|
|
echo "✅ Ollama démarré"
|
|
else
|
|
echo "❌ Erreur : Ollama n'a pas démarré"
|
|
exit 1
|
|
fi
|
|
|
|
# Démarrer Open WebUI si pas déjà lancé
|
|
if ! docker ps | grep -q open-webui; then
|
|
echo "🌐 Démarrage Open WebUI..."
|
|
docker start open-webui 2>/dev/null || \
|
|
docker run -d \
|
|
--gpus all \
|
|
-p 3000:8080 \
|
|
--add-host=host.docker.internal:host-gateway \
|
|
-v open-webui:/app/backend/data \
|
|
--name open-webui \
|
|
--restart always \
|
|
ghcr.io/open-webui/open-webui:cuda
|
|
echo "✅ Open WebUI démarré sur http://localhost:3000"
|
|
else
|
|
echo "✅ Open WebUI déjà actif"
|
|
fi
|
|
|
|
echo ""
|
|
echo "🎉 Stack IA prête !"
|
|
echo "📊 GPU Status:"
|
|
nvidia-smi --query-gpu=name,memory.total,memory.used --format=csv,noheader,nounits
|
|
echo ""
|
|
echo "🔗 Accès:"
|
|
echo " - Open WebUI: http://localhost:3000"
|
|
echo " - Ollama API: http://localhost:11434"
|
|
echo ""
|
|
echo "📝 Modèles disponibles:"
|
|
ollama list
|
|
EOF
|
|
|
|
chmod +x ~/start-ai-stack.sh
|
|
```
|
|
|
|
Utilisation :
|
|
```bash
|
|
~/start-ai-stack.sh
|
|
```
|
|
|
|
### 7.2 Créer un alias dans .bashrc
|
|
|
|
```bash
|
|
echo "alias ai='~/start-ai-stack.sh'" >> ~/.bashrc
|
|
echo "alias ai-stop='docker stop open-webui && pkill ollama'" >> ~/.bashrc
|
|
source ~/.bashrc
|
|
```
|
|
|
|
Maintenant tu peux juste taper `ai` pour tout lancer.
|
|
|
|
### 7.3 Monitoring GPU en temps réel
|
|
|
|
```bash
|
|
# Installer nvtop pour monitoring GPU
|
|
sudo apt install -y nvtop
|
|
|
|
# Lancer
|
|
nvtop
|
|
```
|
|
|
|
Ou utiliser :
|
|
```bash
|
|
watch -n 1 nvidia-smi
|
|
```
|
|
|
|
### 7.4 Script pour tester les performances
|
|
|
|
```bash
|
|
cat > ~/benchmark-models.sh << 'EOF'
|
|
#!/bin/bash
|
|
|
|
echo "🎯 Benchmark des modèles..."
|
|
|
|
PROMPT="Écris une fonction Python qui implémente QuickSort avec commentaires"
|
|
|
|
for MODEL in "qwen2.5-coder:7b" "code-expert" "deepseek-coder-v2:16b"; do
|
|
echo ""
|
|
echo "⏱️ Testing $MODEL..."
|
|
|
|
START=$(date +%s)
|
|
ollama run $MODEL "$PROMPT" > /dev/null 2>&1
|
|
END=$(date +%s)
|
|
|
|
DURATION=$((END - START))
|
|
echo "✅ $MODEL: ${DURATION}s"
|
|
done
|
|
EOF
|
|
|
|
chmod +x ~/benchmark-models.sh
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 8 : Utilisation avancée avec API
|
|
|
|
### 8.1 Script Python pour interagir avec Ollama
|
|
|
|
```bash
|
|
# Installer les dépendances Python
|
|
pip install ollama requests rich
|
|
```
|
|
|
|
```python
|
|
# Créer ~/ai_assistant.py
|
|
cat > ~/ai_assistant.py << 'EOF'
|
|
#!/usr/bin/env python3
|
|
import ollama
|
|
from rich.console import Console
|
|
from rich.markdown import Markdown
|
|
|
|
console = Console()
|
|
|
|
def code_review(code: str, language: str = "python"):
|
|
"""Effectue une review de code."""
|
|
response = ollama.chat(
|
|
model='code-reviewer',
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': f'Review ce code {language}:\n\n```{language}\n{code}\n```'
|
|
}]
|
|
)
|
|
|
|
md = Markdown(response['message']['content'])
|
|
console.print(md)
|
|
|
|
def debug_error(code: str, error: str, language: str = "python"):
|
|
"""Debug une erreur."""
|
|
response = ollama.chat(
|
|
model='debugger',
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': f'''
|
|
Code {language}:
|
|
```{language}
|
|
{code}
|
|
```
|
|
|
|
Erreur:
|
|
```
|
|
{error}
|
|
```
|
|
|
|
Trouve et corrige le bug.
|
|
'''
|
|
}]
|
|
)
|
|
|
|
md = Markdown(response['message']['content'])
|
|
console.print(md)
|
|
|
|
def generate_code(description: str, language: str = "python"):
|
|
"""Génère du code."""
|
|
response = ollama.chat(
|
|
model='code-expert',
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': f'Génère du code {language} pour: {description}'
|
|
}]
|
|
)
|
|
|
|
md = Markdown(response['message']['content'])
|
|
console.print(md)
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
if len(sys.argv) < 2:
|
|
print("Usage:")
|
|
print(" python ai_assistant.py review <fichier>")
|
|
print(" python ai_assistant.py debug <fichier> <erreur>")
|
|
print(" python ai_assistant.py generate '<description>'")
|
|
sys.exit(1)
|
|
|
|
command = sys.argv[1]
|
|
|
|
if command == "review" and len(sys.argv) >= 3:
|
|
with open(sys.argv[2]) as f:
|
|
code = f.read()
|
|
code_review(code)
|
|
|
|
elif command == "generate" and len(sys.argv) >= 3:
|
|
generate_code(sys.argv[2])
|
|
|
|
else:
|
|
print("Commande invalide")
|
|
EOF
|
|
|
|
chmod +x ~/ai_assistant.py
|
|
```
|
|
|
|
Utilisation :
|
|
```bash
|
|
# Review de code
|
|
python ~/ai_assistant.py review mon_script.py
|
|
|
|
# Génération de code
|
|
python ~/ai_assistant.py generate "API REST avec authentification JWT"
|
|
```
|
|
|
|
### 8.2 API REST custom avec FastAPI
|
|
|
|
```bash
|
|
pip install fastapi uvicorn
|
|
```
|
|
|
|
```python
|
|
# Créer ~/code_api.py
|
|
cat > ~/code_api.py << 'EOF'
|
|
from fastapi import FastAPI, HTTPException
|
|
from pydantic import BaseModel
|
|
import ollama
|
|
|
|
app = FastAPI(title="Code AI API")
|
|
|
|
class CodeRequest(BaseModel):
|
|
code: str
|
|
language: str = "python"
|
|
|
|
class PromptRequest(BaseModel):
|
|
prompt: str
|
|
model: str = "code-expert"
|
|
|
|
@app.post("/review")
|
|
async def review_code(request: CodeRequest):
|
|
"""Review du code."""
|
|
try:
|
|
response = ollama.chat(
|
|
model='code-reviewer',
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': f'Review ce code {request.language}:\n\n```{request.language}\n{request.code}\n```'
|
|
}]
|
|
)
|
|
return {"review": response['message']['content']}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@app.post("/generate")
|
|
async def generate_code(request: PromptRequest):
|
|
"""Génération de code."""
|
|
try:
|
|
response = ollama.chat(
|
|
model=request.model,
|
|
messages=[{
|
|
'role': 'user',
|
|
'content': request.prompt
|
|
}]
|
|
)
|
|
return {"code": response['message']['content']}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@app.get("/models")
|
|
async def list_models():
|
|
"""Liste les modèles disponibles."""
|
|
try:
|
|
models = ollama.list()
|
|
return {"models": [m['name'] for m in models['models']]}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
uvicorn.run(app, host="0.0.0.0", port=8000)
|
|
EOF
|
|
```
|
|
|
|
Lancer l'API :
|
|
```bash
|
|
python ~/code_api.py
|
|
```
|
|
|
|
Tester :
|
|
```bash
|
|
# Review de code
|
|
curl -X POST http://localhost:8000/review \
|
|
-H "Content-Type: application/json" \
|
|
-d '{"code": "def add(a,b):\n return a+b", "language": "python"}'
|
|
|
|
# Générer du code
|
|
curl -X POST http://localhost:8000/generate \
|
|
-H "Content-Type: application/json" \
|
|
-d '{"prompt": "Fonction pour valider un email", "model": "code-expert"}'
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 9 : Intégration RAG (Retrieval Augmented Generation)
|
|
|
|
Pour que l'IA utilise ta documentation/codebase :
|
|
|
|
```bash
|
|
pip install chromadb langchain
|
|
```
|
|
|
|
```python
|
|
# Créer ~/rag_codebase.py
|
|
cat > ~/rag_codebase.py << 'EOF'
|
|
#!/usr/bin/env python3
|
|
import chromadb
|
|
from chromadb.config import Settings
|
|
import ollama
|
|
import os
|
|
from pathlib import Path
|
|
|
|
class CodebaseRAG:
|
|
def __init__(self, codebase_path: str):
|
|
self.client = chromadb.Client(Settings(
|
|
chroma_db_impl="duckdb+parquet",
|
|
persist_directory="./chroma_db"
|
|
))
|
|
self.collection = self.client.get_or_create_collection("codebase")
|
|
self.codebase_path = Path(codebase_path)
|
|
|
|
def index_codebase(self):
|
|
"""Indexe tous les fichiers de code."""
|
|
extensions = ['.py', '.js', '.ts', '.java', '.cpp', '.go', '.rs']
|
|
|
|
for ext in extensions:
|
|
for file_path in self.codebase_path.rglob(f'*{ext}'):
|
|
try:
|
|
with open(file_path, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
# Générer l'embedding avec Ollama
|
|
embedding_response = ollama.embeddings(
|
|
model='nomic-embed-text',
|
|
prompt=content
|
|
)
|
|
|
|
self.collection.add(
|
|
ids=[str(file_path)],
|
|
embeddings=[embedding_response['embedding']],
|
|
documents=[content],
|
|
metadatas=[{"path": str(file_path), "ext": ext}]
|
|
)
|
|
print(f"✅ Indexé: {file_path}")
|
|
except Exception as e:
|
|
print(f"❌ Erreur {file_path}: {e}")
|
|
|
|
def query_codebase(self, question: str, n_results: int = 3):
|
|
"""Recherche dans la codebase."""
|
|
# Générer l'embedding de la question
|
|
query_embedding = ollama.embeddings(
|
|
model='nomic-embed-text',
|
|
prompt=question
|
|
)
|
|
|
|
# Chercher les documents similaires
|
|
results = self.collection.query(
|
|
query_embeddings=[query_embedding['embedding']],
|
|
n_results=n_results
|
|
)
|
|
|
|
return results
|
|
|
|
def ask(self, question: str):
|
|
"""Pose une question sur la codebase."""
|
|
# Récupérer les documents pertinents
|
|
results = self.query_codebase(question)
|
|
|
|
# Construire le contexte
|
|
context = "\n\n".join([
|
|
f"Fichier: {meta['path']}\n```\n{doc}\n```"
|
|
for doc, meta in zip(results['documents'][0], results['metadatas'][0])
|
|
])
|
|
|
|
# Générer la réponse avec le contexte
|
|
response = ollama.chat(
|
|
model='code-expert',
|
|
messages=[{
|
|
'role': 'system',
|
|
'content': 'Tu es un expert qui répond aux questions sur une codebase. Utilise le contexte fourni.'
|
|
}, {
|
|
'role': 'user',
|
|
'content': f'''Contexte:\n{context}\n\nQuestion: {question}'''
|
|
}]
|
|
)
|
|
|
|
return response['message']['content']
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
if len(sys.argv) < 3:
|
|
print("Usage:")
|
|
print(" python rag_codebase.py index <chemin_projet>")
|
|
print(" python rag_codebase.py ask '<question>'")
|
|
sys.exit(1)
|
|
|
|
rag = CodebaseRAG("./chroma_db")
|
|
|
|
if sys.argv[1] == "index":
|
|
rag.codebase_path = Path(sys.argv[2])
|
|
rag.index_codebase()
|
|
print("✅ Indexation terminée")
|
|
|
|
elif sys.argv[1] == "ask":
|
|
answer = rag.ask(sys.argv[2])
|
|
print(answer)
|
|
EOF
|
|
|
|
chmod +x ~/rag_codebase.py
|
|
```
|
|
|
|
Utilisation :
|
|
```bash
|
|
# Indexer un projet
|
|
python ~/rag_codebase.py index /chemin/vers/projet
|
|
|
|
# Poser une question
|
|
python ~/rag_codebase.py ask "Comment fonctionne l'authentification dans ce projet ?"
|
|
```
|
|
|
|
---
|
|
|
|
## Étape 10 : Dépannage et optimisations
|
|
|
|
### 10.1 Problèmes courants
|
|
|
|
**Ollama ne démarre pas** :
|
|
```bash
|
|
# Vérifier les processus
|
|
ps aux | grep ollama
|
|
|
|
# Tuer et relancer
|
|
pkill ollama
|
|
ollama serve &
|
|
```
|
|
|
|
**GPU non détecté** :
|
|
```bash
|
|
# Vérifier CUDA
|
|
nvidia-smi
|
|
|
|
# Réinstaller nvidia-container-toolkit
|
|
sudo apt remove --purge nvidia-container-toolkit
|
|
sudo apt install nvidia-container-toolkit
|
|
sudo nvidia-ctk runtime configure --runtime=docker
|
|
sudo systemctl restart docker
|
|
```
|
|
|
|
**Open WebUI ne charge pas** :
|
|
```bash
|
|
# Voir les logs
|
|
docker logs open-webui
|
|
|
|
# Redémarrer
|
|
docker restart open-webui
|
|
|
|
# Si problème persistant, recréer
|
|
docker rm -f open-webui
|
|
# Puis relancer la commande docker run de l'étape 4
|
|
```
|
|
|
|
**Manque de mémoire GPU** :
|
|
```bash
|
|
# Lister les processus GPU
|
|
nvidia-smi
|
|
|
|
# Utiliser des modèles plus petits ou quantizés
|
|
ollama pull qwen2.5-coder:7b-q4_0 # Version plus légère
|
|
```
|
|
|
|
### 10.2 Optimiser les performances
|
|
|
|
**Ajuster les paramètres Ollama** :
|
|
|
|
```bash
|
|
# Créer un fichier de config Ollama
|
|
mkdir -p ~/.ollama
|
|
cat > ~/.ollama/config.json << 'EOF'
|
|
{
|
|
"num_gpu": 1,
|
|
"gpu_layers": 35,
|
|
"num_thread": 8,
|
|
"num_ctx": 8192,
|
|
"batch_size": 512
|
|
}
|
|
EOF
|
|
```
|
|
|
|
**Utiliser la quantization appropriée** :
|
|
|
|
```bash
|
|
# Pour 8GB VRAM
|
|
ollama pull qwen2.5-coder:7b-q5_K_M # Meilleure qualité
|
|
ollama pull qwen2.5-coder:7b-q4_K_M # Équilibré
|
|
ollama pull qwen2.5-coder:7b-q3_K_M # Plus rapide, moins précis
|
|
```
|
|
|
|
### 10.3 Surveillance et monitoring
|
|
|
|
```bash
|
|
# Script de monitoring
|
|
cat > ~/monitor-ai.sh << 'EOF'
|
|
#!/bin/bash
|
|
|
|
echo "📊 Monitoring de l'IA"
|
|
echo "===================="
|
|
echo ""
|
|
|
|
echo "🖥️ GPU:"
|
|
nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu --format=csv,noheader,nounits
|
|
|
|
echo ""
|
|
echo "🐳 Docker Containers:"
|
|
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
|
|
|
|
echo ""
|
|
echo "📦 Ollama Service:"
|
|
if curl -s http://localhost:11434/api/tags > /dev/null; then
|
|
echo "✅ Running"
|
|
echo "Modèles chargés:"
|
|
curl -s http://localhost:11434/api/tags | python3 -m json.tool | grep '"name"'
|
|
else
|
|
echo "❌ Not running"
|
|
fi
|
|
|
|
echo ""
|
|
echo "💾 Espace disque WSL:"
|
|
df -h / | tail -1
|
|
EOF
|
|
|
|
chmod +x ~/monitor-ai.sh
|
|
```
|
|
|
|
---
|
|
|
|
## Récapitulatif des commandes essentielles
|
|
|
|
```bash
|
|
# Démarrer tout
|
|
ai # (alias créé précédemment)
|
|
|
|
# Ou manuellement
|
|
ollama serve &
|
|
docker start open-webui
|
|
|
|
# Arrêter tout
|
|
ai-stop # (alias créé précédemment)
|
|
|
|
# Ou manuellement
|
|
docker stop open-webui
|
|
pkill ollama
|
|
|
|
# Lister les modèles
|
|
ollama list
|
|
|
|
# Utiliser un modèle en CLI
|
|
ollama run code-expert "ton prompt ici"
|
|
|
|
# Monitoring
|
|
~/monitor-ai.sh
|
|
watch -n 1 nvidia-smi
|
|
|
|
# Nettoyer l'espace disque
|
|
docker system prune -a
|
|
ollama rm <model-name> # Supprimer un modèle non utilisé
|
|
```
|
|
|
|
---
|
|
|
|
## Accès et URLs
|
|
|
|
- **Open WebUI** : http://localhost:3000
|
|
- **Ollama API** : http://localhost:11434
|
|
- **API REST custom** : http://localhost:8000 (si lancée)
|
|
|
|
---
|
|
|
|
## Prochaines étapes recommandées
|
|
|
|
1. **Personnaliser les modèles** avec tes propres Modelfiles
|
|
2. **Indexer ta codebase** avec le RAG
|
|
3. **Créer des prompts** spécialisés pour tes langages favoris
|
|
4. **Intégrer avec Git** pour des commits auto-générés
|
|
5. **Automatiser les tests** avec l'IA
|
|
|
|
---
|
|
|
|
## Ressources
|
|
|
|
- Documentation Ollama : https://ollama.ai/docs
|
|
- Open WebUI : https://docs.openwebui.com
|
|
- Continue.dev : https://continue.dev/docs
|
|
- Modèles Ollama : https://ollama.ai/library
|
|
|
|
---
|
|
|
|
**🎉 Félicitations ! Ton IA locale est prête.**
|
|
|
|
Teste-la avec :
|
|
```bash
|
|
ollama run code-expert "Crée une API REST complète avec FastAPI pour gérer des tâches avec authentification JWT"
|
|
```
|