# Guide complet sur Ollama

## 1. Connaissances de base (commandes complètes, commandes NVIDIA pour H100)

### 1.1 Commandes essentielles d'Ollama

Voici les commandes fondamentales pour utiliser Ollama efficacement :

| Commande                         | Description                                           |
| -------------------------------- | ----------------------------------------------------- |
| `ollama serve`                   | Démarre le serveur Ollama sur votre système local     |
| `ollama create <nouveau_modèle>` | Crée un nouveau modèle à partir d'un modèle existant  |
| `ollama show <modèle>`           | Affiche les détails d'un modèle spécifique            |
| `ollama run <modèle>`            | Exécute le modèle spécifié pour interaction           |
| `ollama pull <modèle>`           | Télécharge le modèle spécifié sur votre système       |
| `ollama list`                    | Liste tous les modèles téléchargés                    |
| `ollama ps`                      | Affiche les modèles actuellement en cours d'exécution |
| `ollama stop <modèle>`           | Arrête le modèle spécifié en cours d'exécution        |
| `ollama rm <modèle>`             | Supprime le modèle spécifié de votre système          |

### 1.2 Commandes pour l'utilisation avec GPU NVIDIA (H100)

Pour tirer parti des GPU NVIDIA H100 avec Ollama :

1. **Vérification de l'installation NVIDIA** :
   ```bash
   nvidia-smi
   ```

2. **Variables d'environnement pour l'exécution sur GPU** :
   ```bash
   __NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia ollama run <modèle>
   ```

3. **Vérification de l'utilisation GPU** :
   ```bash
   __NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia glxinfo | grep vendor
   ```

4. **Commandes en cas de problème après mise en veille** (Linux) :
   ```bash
   sudo rmmod nvidia_uvm && sudo modprobe nvidia_uvm
   ```

## 2. Connaissances globales de Ollama

### 2.1 Qu'est-ce qu'Ollama ?

Ollama est une plateforme qui permet d'exécuter des modèles de langage localement sur votre propre ordinateur. Cela facilite l'utilisation de l'IA pour les développeurs et les entreprises sans dépendre de serveurs externes ou d'une connexion internet. La plateforme simplifie le processus d'intégration de l'IA dans vos applications en fournissant des outils pour construire, entraîner et déployer des modèles directement depuis votre environnement local.

### 2.2 Modèles disponibles

Ollama prend en charge une large gamme de modèles. Voici quelques exemples :

| Modèle | Paramètres | Taille | Commande |
|--------|------------|--------|----------|
| Llama 3.1 | 8B | 4.7GB | `ollama run llama3.1` |
| Llama 3.1 | 70B | 40GB | `ollama run llama3.1:70b` |
| Phi 3 Mini | 3.8B | 2.3GB | `ollama run phi3` |
| Phi 3 Medium | 14B | 7.9GB | `ollama run phi3:medium` |
| Gemma 2 | 27B | 16GB | `ollama run gemma2:27b` |
| Mistral | 7B | 4.1GB | `ollama run mistral` |
| Code Llama | 7B | 3.8GB | `ollama run codellama` |

### 2.3 Configuration de base

La configuration d'Ollama se fait généralement dans le fichier `~/.ollama/config.json` :
```json
{
  "host": "127.0.0.1",
  "port": 11434,
  "timeout": 30
}
```

## 3. Connaissances poussées

### 3.1 Exécution dockerisée

Pour utiliser Ollama dans Docker avec support GPU :

```bash
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
```

### 3.2 Création de modèles personnalisés

La création d'un modèle personnalisé se fait via un fichier Modelfile :

```
FROM llama3.1
SYSTEM Je suis un assistant spécialisé dans le développement logiciel.
PARAMETER num_ctx 8192
PARAMETER temperature 0.7
PARAMETER num_gpu 1
```

Puis créez le modèle :
```bash
ollama create mon-assistant -f ./Modelfile
```

### 3.3 Configuration avancée pour les GPU H100

Les H100 sont les GPU les plus puissants de NVIDIA pour l'IA :

- Utilisent des cœurs tenseurs de 4ème génération
- Supportent le FP8 pour une meilleure précision
- Offrent une bande passante mémoire de 3 TB/s
- Fournissent 60 téraflops en double précision (FP64)
- Permettent de gérer des modèles très larges comme Falcon 180B

## 4. Approfondissement partie API

### 4.1 Utilisation de l'API avec curl

L'API Ollama est accessible via HTTP sur le port 11434 par défaut :

```bash
# Génération simple
curl http://localhost:11434/api/generate -d '{ 
  "model": "llama3.1", 
  "prompt": "Comment vas-tu aujourd'hui?"
}'

# Désactiver le streaming pour obtenir une réponse complète
curl http://localhost:11434/api/generate -d '{ 
  "model": "llama3.1", 
  "prompt": "Comment vas-tu aujourd'hui?", 
  "stream": false
}'
```

### 4.2 Intégration avec Python

Installation :
```bash
pip install ollama
```

Exemple d'utilisation :
```python
import ollama

# Génération simple
response = ollama.chat(
    model="llama3.1",
    messages=[
        {"role": "user", "content": "Explique-moi les bases du machine learning."}
    ]
)
print(response['message']['content'])

# Avec streaming
response = ollama.chat(
    model="llama3.1",
    messages=[
        {"role": "user", "content": "Écris un poème sur l'IA."}
    ],
    stream=True
)

for chunk in response:
    print(chunk['message']['content'], end='', flush=True)
```

### 4.3 Endpoints principaux de l'API

- `/api/generate` : Génère du texte à partir d'un prompt
- `/api/chat` : Conversation avec historique
- `/api/embeddings` : Génère des embeddings vectoriels
- `/api/models` : Liste ou gère les modèles
- `/api/pull` : Télécharge un modèle
- `/api/create` : Crée un modèle personnalisé

## 5. Création d'agent avec Ollama

### 5.1 Structure de base d'un agent Ollama

Voici un exemple de classe d'agent Ollama en Python :

```python
from typing import List, Dict, Optional, AsyncIterable, Any
from dataclasses import dataclass

@dataclass
class OllamaAgentOptions:
    streaming: bool = False
    model_id: str = "llama2"
    # Paramètres additionnels (temperature, top_k, top_p, etc.)

class OllamaAgent:
    def __init__(self, options: OllamaAgentOptions):
        self.model_id = options.model_id
        self.streaming = options.streaming
        # Initialisation d'autres attributs

    async def process_request(
        self,
        input_text: str,
        user_id: str,
        session_id: str,
        chat_history: List[Dict],
        additional_params: Optional[Dict[str, str]] = None
    ):
        messages = [
            {"role": msg["role"], "content": msg["content"]}
            for msg in chat_history
        ]
        messages.append({"role": "user", "content": input_text})

        if self.streaming:
            return await self.handle_streaming_response(messages)
        else:
            response = ollama.chat(
                model=self.model_id,
                messages=messages
            )
            return {
                "role": "assistant",
                "content": response['message']['content']
            }

    async def handle_streaming_response(self, messages: List[Dict[str, str]]):
        text = ''
        try:
            response = ollama.chat(
                model=self.model_id,
                messages=messages,
                stream=True
            )
            for part in response:
                text += part['message']['content']
                yield part['message']['content']

            return {
                "role": "assistant",
                "content": text
            }
        except Exception as error:
            print(f"Erreur lors du streaming : {error}")
            raise error
```

### 5.2 Création d'un agent spécialisé

Exemple d'un agent spécialisé pour la programmation :

```python
class OllamaCodingAgent(OllamaAgent):
    def __init__(self):
        super().__init__(OllamaAgentOptions(
            model_id="codellama",
            streaming=True
        ))
        self.system_prompt = "Tu es un assistant de programmation expert. Réponds avec du code clair et bien structuré."
    
    async def process_request(self, input_text, user_id, session_id, chat_history, additional_params=None):
        # Ajouter le system prompt au début de l'historique
        if not chat_history or chat_history[0]["role"] != "system":
            chat_history.insert(0, {"role": "system", "content": self.system_prompt})
        
        return await super().process_request(input_text, user_id, session_id, chat_history, additional_params)
```

### 5.3 Orchestration multi-agents

Exemple d'orchestration de plusieurs agents Ollama :

```python
class OllamaOrchestrator:
    def __init__(self):
        self.agents = {}
        self.sessions = {}
    
    def add_agent(self, agent_id, agent):
        self.agents[agent_id] = agent
    
    def create_session(self, session_id, user_id):
        self.sessions[session_id] = {
            "user_id": user_id,
            "history": []
        }
    
    async def route_request(self, session_id, agent_id, input_text):
        if session_id not in self.sessions:
            self.create_session(session_id, "default_user")
        
        if agent_id not in self.agents:
            raise ValueError(f"Agent {agent_id} non trouvé")
        
        agent = self.agents[agent_id]
        session = self.sessions[session_id]
        
        response = await agent.process_request(
            input_text=input_text,
            user_id=session["user_id"],
            session_id=session_id,
            chat_history=session["history"]
        )
        
        session["history"].append({"role": "user", "content": input_text})
        session["history"].append(response)
        
        return response
```

## 6. Optimisation rapide et pratique du paramétrage des modèles

### 6.1 Paramètres principaux à optimiser

Voici les paramètres clés pour optimiser les performances d'Ollama :

| Paramètre | Description | Valeurs recommandées |
|-----------|-------------|---------------------|
| `temperature` | Contrôle la créativité des réponses | 0.0-1.0 (0.7 par défaut) |
| `top_p` | Sampling de probabilité cumulative | 0.1-1.0 (0.9 par défaut) |
| `top_k` | Nombre de tokens à considérer | 1-100 (40 par défaut) |
| `num_ctx` | Taille du contexte en tokens | 2048-8192 selon modèle |
| `num_gpu` | Nombre de GPU à utiliser | 1 ou plus selon disponibilité |
| `num_thread` | Nombre de threads CPU | Dépend de votre processeur |
| `repeat_penalty` | Pénalité pour répétition | 1.0-1.3 (1.1 par défaut) |

### 6.2 Optimisation selon le cas d'usage

#### Pour la génération de code :
```
PARAMETER temperature 0.2
PARAMETER top_p 0.95
PARAMETER repeat_penalty 1.2
PARAMETER num_ctx 8192
```

#### Pour la créativité :
```
PARAMETER temperature 0.8
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.05
PARAMETER num_ctx 4096
```

#### Pour les réponses factuelles :
```
PARAMETER temperature 0.1
PARAMETER top_p 0.8
PARAMETER repeat_penalty 1.2
PARAMETER num_ctx 4096
```

### 6.3 Technique d'itération pour l'optimisation

1. Commencer avec les paramètres par défaut
2. Ajuster un paramètre à la fois et évaluer les résultats
3. Documenter les changements et leurs effets
4. Tester sur différents types de requêtes
5. Créer des modèles spécialisés pour différents cas d'usage

## 7. Optimisation et intégration dans VSCode/Cursor

### 7.1 Installation et configuration de base

Pour intégrer Ollama dans VSCode/Cursor :

1. **Installer l'extension Continue** :
   ```bash
   code --install-extension Continue.continue
   ```

2. **Configurer l'extension** :
   Ouvrir les paramètres VSCode et configurer Continue :
   ```json
   {
     "continue.model": "ollama",
     "continue.modelParameters": {
       "model": "codellama"
     }
   }
   ```

### 7.2 Utilisation dans VSCode/Cursor

#### Commandes principales :
- Utiliser `Ctrl+Shift+P` (ou `Cmd+Shift+P` sur macOS) puis "Continue: Edit Code" pour générer du code
- Sélectionner du code et utiliser "Continue: Explain Code" pour obtenir des explications
- Utiliser "Continue: Edit Code" sur du code existant pour le refactoriser

#### Modèles recommandés pour VSCode/Cursor :
- **Autocomplétion** : `starcoder2:3b`
- **Génération de code** : `codellama` ou `deepseek-coder:6.7b`
- **Débug et explication** : `llama3.1`

### 7.3 Configuration avancée pour Cursor

Pour Cursor, qui est basé sur VSCode, vous pouvez optimiser davantage :

1. **Configuration pour les projets de grande taille** :
   ```json
   {
     "continue.model": "ollama",
     "continue.modelParameters": {
       "model": "codellama",
       "num_ctx": 8192,
       "temperature": 0.2
     }
   }
   ```

2. **Pour l'utilisation en ligne de commande** :
   ```bash
   # Lancer le serveur Ollama
   ollama serve
   
   # Exécuter le modèle
   ollama run codellama
   ```

3. **Commandes utiles dans l'interface Continue** :
   - `"""` pour les messages multiligne
   - `/bye` pour quitter le modèle

### 7.4 Résolution des problèmes courants

Si vous rencontrez des problèmes :

1. **Vérifier que le serveur Ollama est en cours d'exécution** :
   ```bash
   ps aux | grep ollama
   ```

2. **Redémarrer le serveur** :
   ```bash
   killall ollama
   ollama serve
   ```

3. **Problèmes de performance** :
   - Utiliser un modèle plus petit
   - Fermer les applications gourmandes en ressources
   - Vérifier la disponibilité de la RAM

4. **Si l'extension ne répond pas** :
   - Recharger la fenêtre VSCode/Cursor
   - Vérifier l'état du serveur Ollama
   - Vérifier les paramètres de configuration 
[[Plan d'apprentissage détaillé sur Ollama]]

