Ollama : Intégration de LLMs en local

Qu’est-ce qu’Ollama ?

Ollama est une plateforme open-source permettant d’exécuter et d’intégrer facilement des modèles de langage avancés (LLMs) en local sur un ordinateur ou un serveur. Conçue pour les développeurs et les chercheurs, Ollama simplifie l’utilisation de l’intelligence artificielle sans dépendre d’une infrastructure cloud.

Principales caractéristiques

1. Exécution locale des modèles

Ollama permet de télécharger et d’exécuter des modèles d’intelligence artificielle directement sur une machine locale, garantissant ainsi une exécution rapide, privée et sans dépendance à une connexion Internet.

2. Compatibilité avec plusieurs modèles

La plateforme prend en charge une variété de modèles de langage populaires, notamment ceux basés sur LLaMA, Mistral ou d’autres architectures d’IA, tout en offrant une interface simple pour leur gestion et leur déploiement.

3. Facilité d’utilisation

Avec une interface en ligne de commande intuitive, Ollama permet de charger et d’interagir avec les modèles sans configuration complexe. Une API REST est également disponible pour intégrer facilement les modèles dans des applications.

4. Respect de la confidentialité

Puisque l’exécution des modèles se fait en local, les données traitées ne quittent jamais la machine, ce qui assure une meilleure protection de la vie privée et un contrôle total sur l’utilisation de l’IA.

5. Optimisation des performances

Ollama est conçu pour tirer parti des accélérations matérielles (GPU et CPU) afin d’optimiser l’exécution des modèles et réduire la latence.

Cas d’utilisation

Développement d’assistants IA personnalisés : Intégration dans des applications pour offrir une assistance contextuelle et adaptée aux utilisateurs.
Recherche et expérimentation : Test de modèles en local sans nécessité d’utiliser des services cloud coûteux.
Applications d’entreprise : Traitement de données confidentielles en interne, sans risque de fuite.
Génération de texte et automatisation : Rédaction automatique, analyse de documents, traduction et bien plus encore.

Comment installer Ollama ?

Installation sous Linux

Téléchargez et installez Ollama : curl -fsSL https://ollama.ai/install.sh | sh
Vérifiez l’installation : ollama --version

Cette installation fonctionne sans problème sur un Raspberry PI5 avec 8 GO de ram

Installation sous Windows

Téléchargez l’installateur depuis le site officiel : https://ollama.ai
Exécutez l’installateur et suivez les instructions à l’écran.
Vérifiez l’installation : ollama --version

Installation sous macOS

Téléchargez et installez Ollama via Homebrew : brew install ollama
Vérifiez l’installation : ollama --version

Comment utiliser Ollama ?

L’installation d’Ollama est simple et rapide. Voici les étapes de base pour démarrer :

Charger un modèle : ollama pull mistral
Interagir avec le modèle : ollama run mistral
Utiliser l’API REST pour intégrer Ollama dans une application.

Exemple d’utilisation de l’API REST en Python

Voici un exemple de requête simple envoyée à l’API REST d’Ollama en utilisant Python :

Python

import requests

url = "http://localhost:11434/api/generate"
data = {
    "model": "mistral",
    "prompt": "Expliquez la théorie de la relativité en termes simples.",
    "stream": False
}

response = requests.post(url, json=data)

if response.status_code == 200:
    print(response.json()["response"])
else:
    print("Erreur :", response.status_code, response.text)

Ce script envoie une requête à Ollama pour générer du texte à partir du modèle spécifié et affiche la réponse.

Exemple de Chat dans un terminal

Python

import requests
import json
import itertools
import threading
import time
import sys

def spinner(stop_event):
    """Affiche un spinner tant que stop_event n'est pas activé."""
    for char in itertools.cycle(['|', '/', '-', '\\']):
        if stop_event.is_set():
            break
        sys.stdout.write(f"\rEn attente de la réponse {char}")
        sys.stdout.flush()
        time.sleep(0.1)
    sys.stdout.write("\r" + " " * 30 + "\r")  # Efface le spinner

def poser_question_en_stream(question, modele="llama3.2"):
    print("Modele",modele)
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": modele,
        "prompt": question,
        "stream": True  # Active le mode streaming
    }

    stop_event = threading.Event()
    spinner_thread = threading.Thread(target=spinner, args=(stop_event,))
    spinner_thread.start()

    first_word_received = False

    with requests.post(url, json=payload, stream=True) as response:
        if response.status_code == 200:
            stop_event.set()  # Arrêter le spinner
            spinner_thread.join()

            print("\nRéponse : ", end="", flush=True)

            for ligne in response.iter_lines():
                if ligne:
                    try:
                        data = json.loads(ligne.decode("utf-8"))
                        word = data.get("response", "")
                        print(word, end="", flush=True)

                        if not first_word_received:
                            first_word_received = True

                    except json.JSONDecodeError:
                        pass  # Ignorer les erreurs JSON

            print("\n")  # Ajoute une nouvelle ligne après la réponse complète
        else:
            stop_event.set()  # Arrêter le spinner en cas d'erreur
            spinner_thread.join()
            print(f"\nErreur : {response.status_code}, {response.text}")

#modele="mistral"
modele="llama3.2"

print("Taper 'quit' pour arrêter l'application")
while True:
    question = input(">>> ")
    if question.lower() == "quit":
        break
    poser_question_en_stream(question,modele)

Exemple d’exécution

Plain Text

Taper 'quit' pour arrêter l'application
>>> Pourquoi le ciel est bleu ?
Modele llama3.2

Réponse : Le ciel est en effet bleu, mais pourquoi ? C'est une question qui a intrigué les scientifiques et les curieux pendant des siècles !

La bonne réponse se trouve dans la physique. Lorsque la lumière du soleil passe à travers l'atmosphère terrestre, elle rencontre des atomes d'azote (N2) et d'oxygène (O2). Ces atomes absorbent les longueurs d'onde de la lumière, en particulier les rouges et les oranges.

La lumière restante, c'est-à-dire la lumière bleue, peut se propager librement à travers l'atmosphère. C'est pourquoi le ciel apparaît bleu, car nous voyons uniquement cette lumière bleue qui arrive à nos yeux.

Mais pourquoi pas un autre couleur ? La raison est que les longueurs d'onde de la lumière sont tranchées et que chaque couleur correspond à une plage spécifique de longueurs d'onde. L'azote et l'oxygène absorbent les longueurs d'onde du rouge, du vert et du violet, mais pas celles du bleu.

Il y a également une autre raison pour laquelle le ciel est bleu : la réfraction de la lumière. Lorsque la lumière passe d'un gaz à un autre, elle change de direction en raison des différences dans les masses et les charges des atomes. La réfraction du bleu est plus grande que celle des autres couleurs, ce qui signifie que le bleu se propage plus facilement à travers l'atmosphère.

En résumé, le ciel est bleu parce que les atomes d'azote et d'oxygène absorbent les longueurs d'onde du rouge, du vert et du violet, laissant seul le bleu pour se propager librement à travers l'atmosphère. C'est une combinaison de physique et de chimie qui explique pourquoi le ciel est bleu !

>>>

Exemple avec un GUI et sélection de modèles

Python

import tkinter as tk
from tkinter import ttk
import requests
import json
import itertools
import threading
import time
import os
"""
ollama list
NAME                      ID              SIZE      MODIFIED
llama3.2-vision:latest    085a1fdae525    7.9 GB    15 hours ago
codellama:latest          8fdf8f752f6e    3.8 GB    16 hours ago
phi4:latest               ac896e5b8b34    9.1 GB    18 hours ago
gemma2:27b                53261bc9c192    15 GB     19 hours ago
DeepSeek-R1:latest        0a8c26691023    4.7 GB    21 hours ago
mistral:latest            f974a74358d6    4.1 GB    41 hours ago
llama3.2:latest           a80c4f17acd5    2.0 GB    42 hours ago
"""
def fetch_models():
    return ["llama3.2", "mistral","DeepSeek-R1","gemma2:27b","phi4","codellama"]

def spinner(stop_event, label):
    for char in itertools.cycle(['|', '/', '-', '\\']):
        if stop_event.is_set():
            break
        label.config(text=f"En attente de la réponse {char}")
        time.sleep(0.1)
    label.config(text="")

def poser_question_en_stream(event=None):
    start_time = time.time()
    question = entry_question.get("1.0", tk.END).strip()
    modele = model_var.get()
    if not question:
        return
    
    response_text.delete(1.0, tk.END)
    response_text.insert(tk.END, question+"\n")
    url = "http://localhost:11434/api/generate"
    payload = {"model": modele, "prompt": question, "stream": True}
    
    stop_event = threading.Event()
    spinner_label.config(text="En attente de la réponse")
    spinner_thread = threading.Thread(target=spinner, args=(stop_event, spinner_label))
    spinner_thread.start()
    
    def fetch_response():
        first_word_received = False
        try:
            with requests.post(url, json=payload, stream=True) as response:
                stop_event.set()
                spinner_thread.join()
                
                if response.status_code == 200:
                    for ligne in response.iter_lines():
                        if ligne:
                            try:
                                data = json.loads(ligne.decode("utf-8"))
                                word = data.get("response", "")
                                response_text.insert(tk.END, word)
                                response_text.see(tk.END)
                                if not first_word_received:
                                    first_word_received = True
                            except json.JSONDecodeError:
                                pass
                else:
                    response_text.insert(tk.END, f"Erreur : {response.status_code}, {response.text}")
                response_text.insert(tk.END,f"\n— Durée {(time.time()-start_time):.2f} secondes —")
        except requests.exceptions.RequestException as e:
            stop_event.set()
            spinner_thread.join()
            response_text.insert(tk.END, f"Erreur de connexion : {str(e)}")
    
    threading.Thread(target=fetch_response, daemon=True).start()

def save_window_geometry():
    with open("window_geometry.txt", "w") as f:
        f.write(f"{root.winfo_x()}x{root.winfo_y()}x{root.winfo_width()}x{root.winfo_height()}")

def load_window_geometry():
    if os.path.exists("window_geometry.txt"):
        with open("window_geometry.txt", "r") as f:
            data = f.read().strip()
            try:
                x, y, w, h = map(int, data.split("x"))
                root.geometry(f"{w}x{h}+{x}+{y}")
            except ValueError:
                pass

# Création de la fenêtre principale
root = tk.Tk()
root.title("Interface Chatbot")
load_window_geometry()
root.protocol("WM_DELETE_WINDOW", lambda: (save_window_geometry(), root.destroy()))

# Sélection du modèle
ttk.Label(root, text="Modèle :").pack(pady=5)
models = fetch_models()
model_var = tk.StringVar(value=models[0] if models else "llama3.2")
model_dropdown = ttk.Combobox(root, textvariable=model_var, values=models, state="readonly")
model_dropdown.pack(pady=5, fill=tk.X)

# Création du PanedWindow
paned_window = tk.PanedWindow(root, orient=tk.VERTICAL)
paned_window.pack(fill=tk.BOTH, expand=True)

# Zone de saisie de la question
frame_question = ttk.Frame(paned_window)
ttk.Label(frame_question, text="Votre question :").pack(pady=5)
entry_question = tk.Text(frame_question, height=3, wrap=tk.WORD)
entry_question.pack(pady=5, fill=tk.BOTH, expand=True)
entry_question.bind("<Return>", poser_question_en_stream)
paned_window.add(frame_question)

# Label du spinner
spinner_label = ttk.Label(frame_question, text="")
spinner_label.pack(pady=5)

# Zone d'affichage de la réponse
frame_response = ttk.Frame(paned_window)
response_text = tk.Text(frame_response, wrap=tk.WORD)
response_text.pack(pady=5, expand=True, fill=tk.BOTH)
paned_window.add(frame_response)

# Ajustement automatique de la zone de réponse
root.grid_rowconfigure(4, weight=1)
root.grid_columnconfigure(0, weight=1)

# Boucle principale
root.mainloop()

Exemple d’analyse d’images

Le modèle llama3.2-vision permet d’analyser le contenu d’une image.

Python

import requests
import json
import base64
import threading
import tkinter as tk
from tkinter import filedialog, ttk
from PIL import Image, ImageTk
import io

# Configuration du modèle
MODEL = "llama3.2-vision"
SERVER_URL = "http://localhost:11434/api/generate"

class LlamaApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Chat avec Llama3.2-Vision")
        self.root.geometry("600×500")
        
        # Stockage de l'image encodée en base64
        self.image_base64 = None
        self.image_display = None  # Image affichée

        # Champ de question
        self.label_question = ttk.Label(root, text="Entrez votre question :")
        self.label_question.pack(pady=5)

        self.entry_question = ttk.Entry(root, width=60)
        self.entry_question.pack(pady=5)
        self.entry_question.bind("<Return>", self.envoyer_question)

        # Bouton pour charger une image
        self.button_load_image = ttk.Button(root, text="Charger une image", command=self.charger_image)
        self.button_load_image.pack(pady=5)

        # Zone d'affichage de l'image
        self.label_image = ttk.Label(root)
        self.label_image.pack(pady=5)

        # Bouton envoyer
        self.button_envoyer = ttk.Button(root, text="Envoyer", command=self.envoyer_question)
        self.button_envoyer.pack(pady=5)

        # Zone d'affichage de la réponse
        self.label_reponse = ttk.Label(root, text="Réponse :", font=("Arial", 12, "bold"))
        self.label_reponse.pack(pady=5)

        self.text_reponse = tk.Text(root, height=10, wrap=tk.WORD)
        self.text_reponse.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

    def charger_image(self):
        """Ouvre une boîte de dialogue pour sélectionner une image et la charge en base64"""
        file_path = filedialog.askopenfilename(title="Sélectionner une image",
                                               filetypes=[("Images", "*.jpg *.jpeg *.png *.bmp *.gif")])
        if file_path:
            try:
                # Encodage en base64
                with open(file_path, "rb") as f:
                    self.image_base64 = base64.b64encode(f.read()).decode("utf-8")

                # Afficher l'image dans l'interface
                image = Image.open(file_path)
                image.thumbnail((200, 200))  # Redimensionner pour affichage
                self.image_display = ImageTk.PhotoImage(image)

                self.label_image.config(image=self.image_display)
                self.label_image.image = self.image_display  # Préserver la référence
            except Exception as e:
                self.text_reponse.insert(tk.END, f"Erreur lors du chargement de l'image : {e}\n")

    def envoyer_question(self, event=None):
        """Envoie la question à l'API et affiche la réponse"""
        question = self.entry_question.get().strip()
        if not question:
            return

        self.text_reponse.delete("1.0", tk.END)  # Efface l'ancienne réponse
        self.text_reponse.insert(tk.END, "En attente de la réponse…\n")
        self.root.update_idletasks()

        threading.Thread(target=self.envoyer_requete, args=(question,), daemon=True).start()

    def envoyer_requete(self, question):
        """Envoie une requête au modèle avec ou sans image"""
        payload = {
            "model": MODEL,
            "prompt": question,
            "stream": True  # Active le mode streaming
        }

        if self.image_base64:
            payload["images"] = [self.image_base64]  # Ajoute l'image si disponible

        try:
            with requests.post(SERVER_URL, json=payload, stream=True) as response:
                if response.status_code == 200:
                    self.text_reponse.delete("1.0", tk.END)
                    for ligne in response.iter_lines():
                        if ligne:
                            try:
                                data = json.loads(ligne.decode("utf-8"))
                                word = data.get("response", "")
                                self.text_reponse.insert(tk.END, word)
                                self.text_reponse.see(tk.END)  # Scroll automatique
                                self.root.update_idletasks()
                            except json.JSONDecodeError:
                                pass
                else:
                    self.text_reponse.insert(tk.END, f"\nErreur : {response.status_code}, {response.text}")
        except requests.exceptions.RequestException as e:
            self.text_reponse.insert(tk.END, f"\nErreur de connexion : {e}")

if __name__ == "__main__":
    root = tk.Tk()
    app = LlamaApp(root)
    root.mainloop()

Grimeco

Ollama : Intégration de LLMs en local

Qu’est-ce qu’Ollama ?

Principales caractéristiques

1. Exécution locale des modèles

2. Compatibilité avec plusieurs modèles

3. Facilité d’utilisation

4. Respect de la confidentialité

5. Optimisation des performances

Cas d’utilisation

Comment installer Ollama ?

Installation sous Linux

Installation sous Windows

Installation sous macOS

Comment utiliser Ollama ?

Exemple d’utilisation de l’API REST en Python

Exemple de Chat dans un terminal

Exemple avec un GUI et sélection de modèles

Exemple d’analyse d’images

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Raspberry Radio Internet (Partie 1)

DeOldify : Redonner Vie aux Photos et Vidéos en Noir et Blanc

Laisser un commentaire Annuler la réponse