AIagent/guide_ollama_complet.md

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 :

   nvidia-smi
   

2. Variables d'environnement pour l'exécution sur GPU :

   __NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia ollama run <modèle>
   

3. Vérification de l'utilisation GPU :

   __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) :

   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 :

{
  "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 :

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 :

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 :

# 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 :

pip install ollama

Exemple d'utilisation :

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 :

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 :

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 :

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 :

   code --install-extension Continue.continue
   

2. Configurer l'extension : Ouvrir les paramètres VSCode et configurer Continue :

   {
     "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 :

   {
     "continue.model": "ollama",
     "continue.modelParameters": {
       "model": "codellama",
       "num_ctx": 8192,
       "temperature": 0.2
     }
   }
   

2. Pour l'utilisation en ligne de commande :

   # 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 :

   ps aux | grep ollama
   

2. Redémarrer le serveur :

   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