first commit

guide_ollama_complet.md

@@ -0,0 +1,444 @@
+# 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 

prompt.txt

@@ -0,0 +1,9 @@
+Je voudrai approfondir mes connaissances sur ollama:
+Pour chaques points ci-dessous je voudrai que tu considère que je suis un débutant mais que j'intègre les informations rapidement, que tu établisses un plan détaillé de chaque sections, et que tu détailles autant que tu peux
+1. Connaissances de bases (commandes complètes, commandes nividia (car utilisation H100))
+2. Connaissances globales de ollama
+3. Connaisances poussées 
+4. Approfondissement partie API 
+5. Création d'agent avec Ollama (utilisation de classes ollama général, puis classes modèle dédié)
+6. Optimisation rapide et pratique du paramétrage des paramètres du modèle ollama global et des autres modèles
+7. Optimisation et intégration dans vscode plus précisement j'utilise cursor (la aussi explication et mise en place détaillée)

test.md

@@ -0,0 +1,47 @@
+### 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
+```
+#### 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
+ollma run llama3 "Quelle est la capitale de la France?"
+```
+
+- Gestion avancée des modèles :
+
+```bash
+ollama show llama3
+ollama rm llama3
+```