
---
## 1. 🛠️ Connaissances de base et commandes essentielles

### a. Installation et configuration initiale

- Installation sur Linux/Windows/macOS :
    
    ```bash
    curl -fsSL https://ollama.com/install.sh | sh
    ```
    
- Vérifier l'installation :
    
    ```bash
    ollama --version
    ```
    
- Lancer le serveur Ollama :
    
    ```bash
    ollama serve
    ```
    

### b. Commandes complètes de base

- Afficher les modèles disponibles :
    
    ```bash
    ollama list
    ```
    
- Télécharger un modèle précis :
    
    ```bash
    ollama pull llama3
    ```
    
- Lancer un prompt rapidement :
    
    ```bash
    ollama run llama3 "Quelle est la capitale de la France?"
    ```
    
- Gestion avancée des modèles :
    
    ```bash
    ollama show llama3
    ollama rm llama3
    ```
    

### c. Utilisation des commandes GPU Nvidia (spécifique H100)

- Vérification GPU disponible :
    
    ```bash
    nvidia-smi
    ```
    
- Configuration spécifique GPU Nvidia pour Ollama :
    
    - Ollama utilise automatiquement CUDA lorsqu'un GPU Nvidia est disponible, mais vérifier le support CUDA :
    
    ```bash
    nvcc --version
    ```
    
- Monitoring GPU durant l'utilisation Ollama :
    
    ```bash
    watch -n 1 nvidia-smi
    ```
    
- Optimisation d'utilisation GPU (exemple H100) :
    - S'assurer d'avoir installé CUDA Toolkit 12.x (compatible H100).
    - Gestion des ressources GPU (notamment via variables d'environnement si besoin spécifique) :
        
        ```bash
        export CUDA_VISIBLE_DEVICES=0  # pour préciser le GPU à utiliser
        ```
        

---

## 2. 🌐 Connaissances globales sur Ollama

### a. Architecture générale d'Ollama

- Composants principaux :
    - Ollama server (gestion des requêtes et des modèles)
    - Modèles supportés (LLaMA, Gemma, Mistral, LLaVA, Codellama…)
    - Communication via REST API locale

### b. Modèles disponibles et usages recommandés

- Modèles linguistiques (LLM) généraux (LLaMA3, Mistral, Mixtral…)
- Modèles spécialisés (CodeLLaMA pour code, LLaVA pour multimodal…)

### c. Bonnes pratiques

- Gestion et stockage des modèles (volumes importants)
- Mise à jour régulière des modèles
- Structuration simple des requêtes de test

---

## 3. 🚀 Connaissances poussées et avancées

### a. Déploiement en production (serveur, VM, cloud)

- Dockerisation Ollama
    
    ```bash
    docker run -d -p 11434:11434 -v ~/.ollama:/root/.ollama ollama/ollama
    ```
    
- Automatisation (docker-compose, Kubernetes)

### b. Modèles avancés et optimisation

- Fine-tuning personnalisé (concept théorique, actuellement limité sur Ollama)
- Création de modèles personnalisés via Ollama (`ollama create`)

### c. Benchmark et évaluation de performances

- Tests de vitesse et de latence des modèles :
    
    ```bash
    ollama run --verbose llama3 "test de performance"
    ```
    
- Monitoring continu et logging avancé

---

## 4. ⚙️ Approfondissement de l’API Ollama

### a. Structure de l'API Ollama REST

- Documentation officielle :
    - Endpoint : `http://localhost:11434/api/generate`
- Exemples d’appel :
    
    ```bash
    curl -X POST http://localhost:11434/api/generate -d '{"model": "llama3", "prompt":"Hello World"}'
    ```
    

### b. Gestion de conversations via l'API

- Conversations avec contexte :
    
    ```json
    {
      "model": "llama3",
      "messages": [{"role":"user","content":"message"}]
    }
    ```
    
- Gestion d’états (`context`)

### c. API streaming et événements temps réel

- Mode Streaming via API :
    
    ```json
    {
      "model": "llama3",
      "prompt": "Explain streaming...",
      "stream": true
    }
    ```
    
- Gestion asynchrone en Node.js ou Python

---

## 5. 🤖 Création d’agents intelligents avec Ollama

### a. Concepts fondamentaux des agents

- Définition : Action autonome d'un LLM en boucle interactive
- Principe de boucle agentique :
    
    ```
    Perception → Réflexion → Action → Observation → (répétition)
    ```
    

### b. Implémentation simple d’un agent Ollama (Python)

- Exemple avec classe générale Ollama (via requests, LangChain ou Ollama Python SDK)
- Utiliser LangChain pour une implémentation rapide d’agents :
    
    ```python
    from langchain.llms import Ollama
    from langchain.agents import initialize_agent, AgentType
    
    llm = Ollama(model="llama3")
    agent = initialize_agent(agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, tools=[], llm=llm)
    agent.run("Quelle est la météo à Paris aujourd’hui ?")
    ```
    

### c. Implémentation avancée d'agents personnalisés

- Création de classes d'agents spécialisés par métier ou par domaine
- Gestion des contextes longs, mémoire et persistance d'état

---

## 6. ⚡ Optimisation pratique des paramètres des modèles Ollama

### a. Paramétrage global du modèle

- Modifier le fichier de configuration général :
    
    ```bash
    ~/.ollama/config.json
    ```
    
- Paramètres principaux à optimiser :
    - `num_ctx` (taille du contexte)
    - `temperature`, `top_p`, `repeat_penalty` (contrôle créativité)

### b. Paramétrage avancé spécifique à chaque modèle

- Comparaison et réglage rapide via commandes :
    
    ```bash
    ollama run llama3 --temperature 0.7 "Prompt ici"
    ```
    
- Bonnes pratiques d'optimisation pour usages courants (créatif vs précis)

---

## 7. 🖥️ Intégration et optimisation dans VSCode/Cursor IDE

### a. Installation et intégration Ollama dans VSCode avec Cursor

- Installation extension officielle Ollama dans Cursor :
    
    ```
    Ctrl+Shift+X → rechercher "Ollama"
    ```
    
- Configuration extension Ollama (serveur local) :
    - URL serveur Ollama dans settings.json :
        
        ```json
        "ollama.endpoint": "http://localhost:11434"
        ```
        

### b. Optimisation et utilisation pratique dans l'IDE

- Prompt rapide dans VSCode/Cursor via raccourcis clavier
- Utilisation contextuelle pour génération automatique de code/documentation :
    
    ```json
    "cursor.promptTemplates": [
      {
        "name": "Code Explain",
        "prompt": "Explique le code suivant simplement : {{selection}}"
      }
    ]
    ```
    
- Création de snippets intelligents avec Ollama

### c. Productivité avancée avec Cursor et Ollama

- Commandes rapides (code generation, refactoring, debugging)
- Personnalisation des interactions Ollama/Cursor selon projets (JS, Node, Python, etc.)

---

🚩 **Étape suivante :**  
Tu peux débuter par le premier point en suivant précisément ces sections. À chaque étape franchie, je peux approfondir selon tes besoins ou répondre précisément à tes questions pratiques ou théoriques sur Ollama.