# Installation via brew (recommandé)
brew install ollama

# Ou via script officiel
curl -fsSL https://ollama.com/install.sh | sh

# Démarrer le service
ollama serve
# Le serveur démarre sur http://localhost:11434

# Installation automatique
curl -fsSL https://ollama.com/install.sh | sh

# Démarrer comme service systemd
sudo systemctl start ollama
sudo systemctl enable ollama  # Démarrage automatique au boot

# Vérifier status
sudo systemctl status ollama

# Vérifier détection GPU
nvidia-smi

# Ollama utilisera automatiquement le GPU

# Dans WSL2 Ubuntu
curl -fsSL https://ollama.com/install.sh | sh
ollama serve

# Tester que Ollama fonctionne
ollama --version
# Sortie : ollama version 0.1.x

# Lister modèles installés (vide pour l'instant)
ollama list

# Tester avec un petit modèle
ollama run phi
# Télécharge phi (~2.7B paramètres) et lance un chat

ollama run <model_name>:<tag>

# Télécharger et lancer Llama 3.1 8B (quantization par défaut : Q4)
ollama run llama3.1

# Spécifier variante de quantization
ollama run llama3.1:70b-instruct-q4_K_M  # 70B paramètres, Q4_K_M
ollama run llama3.1:8b-instruct-q8_0     # 8B paramètres, Q8 (meilleure qualité, plus lourd)

# Mistral en français
ollama run mistral

# Gemma 2
ollama run gemma2:27b

$ ollama run llama3.1
pulling manifest
pulling 8eeb52dfb3bb... 100% ▕████████████████▏ 4.7 GB
pulling 948af2743fc7... 100% ▕████████████████▏  1.5 KB
pulling 0ba8f0e314b4... 100% ▕████████████████▏  12 KB
pulling 56bb8bd477a5... 100% ▕████████████████▏   96 B
pulling 1a4c3c319823... 100% ▕████████████████▏  485 B
verifying sha256 digest
writing manifest
removing any unused layers
success

>>> Send a message (/? for help)

>>> Explique-moi ce qu'est un LLM en termes simples

Un LLM (Large Language Model) est un modèle d'intelligence artificielle
entraîné sur d'énormes quantités de texte pour comprendre et générer du
langage naturel. Imagine un assistant qui a "lu" l'équivalent de millions
de livres et peut répondre à des questions, écrire des textes, traduire,
coder, etc. Les LLMs comme GPT, Claude ou Llama fonctionnent en prédisant
le mot suivant le plus probable dans une séquence, token par token.

>>> Donne-moi un exemple de code Python pour lire un fichier CSV

Voici un exemple simple avec la bibliothèque pandas :

```python
import pandas as pd

# Lire le fichier CSV
df = pd.read_csv('data.csv')

# Afficher les premières lignes
print(df.head())

# Afficher informations sur les colonnes
print(df.info())

**Commandes spéciales en mode chat** :
- `/bye` : Quitter
- `/clear` : Effacer l'historique de conversation
- `/show` : Afficher paramètres du modèle
- `/load <model>` : Charger un autre modèle
- `/?` : Aide

```bash
>>> /show info
Model
  architecture        llama
  parameters          8.0B
  context length      8192
  embedding length    4096
  quantization        Q4_K_M

# Lister modèles installés
ollama list

# Sortie exemple :
# NAME                ID              SIZE    MODIFIED
# llama3.1:latest     42182419e950    4.7 GB  2 hours ago
# mistral:latest      61e88e884507    4.1 GB  1 day ago
# codellama:latest    8fdf8f752f6e    3.8 GB  3 days ago

# Supprimer un modèle
ollama rm llama3.1

# Mettre à jour un modèle
ollama pull llama3.1

# Pull sans lancer
ollama pull gemma2

# Voir détails d'un modèle
ollama show llama3.1

# Copier un modèle avec nouveau nom
ollama cp llama3.1 my-custom-llama

# Réponse directe (non-interactif)
ollama run llama3.1 "Quelle est la capitale de la France ?"

# Sortie :
# La capitale de la France est Paris.

# Rediriger sortie
ollama run codellama "Écris une fonction Python pour calculer la factorielle" > factorial.py

#!/bin/bash

MODEL="llama3.1"
PROMPT="Analyse ce log d'erreur : $(cat error.log)"

RESPONSE=$(ollama run $MODEL "$PROMPT")

echo "Diagnostic IA :"
echo "$RESPONSE"

# Envoyer par email, logger, etc.

# POST /api/generate
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "Why is the sky blue?",
  "stream": false
}'

{
  "model": "llama3.1",
  "created_at": "2025-01-15T10:30:00Z",
  "response": "The sky appears blue due to Rayleigh scattering...",
  "done": true,
  "context": [128, 564, ...],
  "total_duration": 3247892000,
  "load_duration": 48203000,
  "prompt_eval_duration": 527841000,
  "eval_duration": 2671848000
}

# POST /api/chat
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1",
  "messages": [
    {"role": "system", "content": "Tu es un assistant serviable."},
    {"role": "user", "content": "Quelle est la capitale du Japon ?"}
  ],
  "stream": false
}'

# Streaming de tokens (Server-Sent Events)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "Écris une courte histoire",
  "stream": true
}'

# Sortie progressive :
# {"response": "Il", "done": false}
# {"response": " était", "done": false}
# {"response": " une", "done": false}
# {"response": " fois", "done": false}
# ...
# {"done": true}

import requests
import json

class OllamaClient:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url

    def generate(self, model, prompt, stream=False, **kwargs):
        """Générer texte depuis prompt"""
        url = f"{self.base_url}/api/generate"
        data = {
            "model": model,
            "prompt": prompt,
            "stream": stream,
            **kwargs
        }

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

        if stream:
            # Streaming mode
            for line in response.iter_lines():
                if line:
                    yield json.loads(line)
        else:
            return response.json()

    def chat(self, model, messages, stream=False, **kwargs):
        """Chat avec historique"""
        url = f"{self.base_url}/api/chat"
        data = {
            "model": model,
            "messages": messages,
            "stream": stream,
            **kwargs
        }

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

        if stream:
            for line in response.iter_lines():
                if line:
                    yield json.loads(line)
        else:
            return response.json()

# Utilisation
client = OllamaClient()

# Génération simple
result = client.generate(
    model="llama3.1",
    prompt="Explique la relativité en une phrase",
    temperature=0.7
)
print(result["response"])

# Chat avec mémoire
messages = [
    {"role": "system", "content": "Tu es un expert Python."},
    {"role": "user", "content": "Comment lire un fichier JSON ?"}
]

response = client.chat(model="codellama", messages=messages)
print(response["message"]["content"])

# Streaming
print("Génération progressive :")
for chunk in client.generate(model="mistral", prompt="Écris un poème", stream=True):
    if not chunk.get("done"):
        print(chunk["response"], end="", flush=True)

from openai import OpenAI

# Pointer vers Ollama au lieu d'OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Requis mais non utilisé
)

# Utiliser exactement comme OpenAI
response = client.chat.completions.create(
    model="llama3.1",
    messages=[
        {"role": "system", "content": "Tu es un assistant serviable."},
        {"role": "user", "content": "Quelle est la hauteur de l'Everest ?"}
    ],
    temperature=0.7,
    max_tokens=150
)

print(response.choices[0].message.content)

# Streaming
stream = client.chat.completions.create(
    model="mistral",
    messages=[{"role": "user", "content": "Conte une blague"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import os

# Configuration dynamique
USE_LOCAL = os.getenv("USE_LOCAL_LLM", "false").lower() == "true"

if USE_LOCAL:
    client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
    model = "llama3.1"
else:
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    model = "gpt-4o"

# Le reste du code est identique !
response = client.chat.completions.create(
    model=model,
    messages=[...]
)

# Modelfile
FROM llama3.1

# System prompt personnalisé
SYSTEM """
Tu es un expert en cybersécurité, spécialisé dans l'analyse de vulnérabilités.
Tu réponds de manière concise et technique.
Tu fournis toujours des exemples de code quand pertinent.
"""

# Paramètres de génération
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 4096  # Taille du contexte

# Message d'accueil
TEMPLATE """{{ if .System }}System: {{ .System }}{{ end }}
User: {{ .Prompt }}
Assistant: """

# Créer Modelfile
cat > Modelfile <<EOF
FROM mistral

SYSTEM "Tu es un poète romantique du 19e siècle. Tu t'exprimes avec élégance et lyrisme."

PARAMETER temperature 0.9
PARAMETER top_p 0.95
EOF

# Créer le modèle custom
ollama create romantic-poet -f Modelfile

# Utiliser le modèle
ollama run romantic-poet

>>> Décris la lune
Ô douce clarté lunaire, astre argenté qui règne sur la voûte céleste nocturne !
Telle une perle suspendue dans l'éther, tu verses ta lumière d'albâtre...

FROM codellama:13b

SYSTEM """
Tu es un senior software engineer expert en clean code.

Règles strictes :
- Code commenté et documenté
- Gestion d'erreurs explicite
- Respect PEP 8 (Python) ou conventions du langage
- Tests unitaires si demandé
- Pas de solutions "quick and dirty"

Format de réponse :
1. Explication de l'approche
2. Code complet
3. Exemples d'utilisation
4. Tests (si applicable)
"""

PARAMETER temperature 0.3  # Bas = plus déterministe pour code
PARAMETER top_p 0.9

ollama create clean-coder -f Modelfile
ollama run clean-coder "Écris une fonction pour valider une adresse email"

FROM llama3.1:8b

SYSTEM """
Tu es un tuteur patient et pédagogue pour étudiants débutants.

Méthode d'enseignement :
1. Commence par expliquer le concept simplement (analogie si possible)
2. Donne un exemple concret
3. Pose une question pour vérifier la compréhension
4. Encourage et félicite les efforts

Ton : Amical, encourageant, jamais condescendant
Ne donne jamais directement la réponse complète, guide plutôt
"""

PARAMETER temperature 0.8

FROM llama3.1:8b

SYSTEM """
Tu es un extracteur de données. Tu réponds UNIQUEMENT en JSON valide, rien d'autre.
Format JSON strict sans commentaires ni texte additionnel.
"""

PARAMETER temperature 0.1  # Très bas pour consistance
PARAMETER top_k 10

ollama create json-extractor -f Modelfile

echo "Extrais les infos : Jean Dupont, né le 15/03/1985 à Paris, ingénieur" | \
  ollama run json-extractor
# {
#   "nom": "Dupont",
#   "prenom": "Jean",
#   "date_naissance": "1985-03-15",
#   "lieu_naissance": "Paris",
#   "profession": "ingénieur"
# }

# Modelfile
FROM https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q4_K_M.gguf

SYSTEM "Tu es un assistant serviable."

PARAMETER temperature 0.7

ollama create llama2-13b-custom -f Modelfile

from langchain_community.llms import Ollama
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Initialiser Ollama
llm = Ollama(
    model="llama3.1",
    base_url="http://localhost:11434",
    temperature=0.7
)

# Utiliser avec LangChain
prompt = PromptTemplate(
    input_variables=["product"],
    template="Rédige une description marketing pour {product}"
)

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(product="un smartphone pliable")
print(result)

# RAG avec Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA

# [Embeddings](/ia/embedding/) locaux
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Charger documents
from langchain_community.document_loaders import TextLoader
loader = TextLoader("documentation.txt")
documents = loader.load()

# Chunking
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

# Base vectorielle locale
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# RAG Chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# Question
response = qa_chain.run("Comment installer Python ?")
print(response)

from llama_index.llms.ollama import Ollama
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.ollama import OllamaEmbedding

# LLM local
llm = Ollama(model="llama3.1", request_timeout=120.0)

# Embeddings locaux
embed_model = OllamaEmbedding(model_name="nomic-embed-text")

# Charger documents
documents = SimpleDirectoryReader("./data").load_data()

# Créer index
index = VectorStoreIndex.from_documents(
    documents,
    llm=llm,
    embed_model=embed_model
)

# Query engine
query_engine = index.as_query_engine()

response = query_engine.query("Résume les points clés du document")
print(response)

import gradio as gr
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

def chat_with_ollama(message, history, model):
    """Chat function pour Gradio"""
    # Convertir historique Gradio en format OpenAI
    messages = []
    for human, ai in history:
        messages.append({"role": "user", "content": human})
        messages.append({"role": "assistant", "content": ai})
    messages.append({"role": "user", "content": message})

    # Appeler Ollama
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        stream=False
    )

    return response.choices[0].message.content

# Interface Gradio
with gr.Blocks() as demo:
    gr.Markdown("# Chat avec Ollama")

    model_dropdown = gr.Dropdown(
        choices=["llama3.1", "mistral", "codellama", "gemma2"],
        value="llama3.1",
        label="Choisir modèle"
    )

    chatbot = gr.Chatbot()
    msg = gr.Textbox(placeholder="Votre message...")

    msg.submit(
        chat_with_ollama,
        inputs=[msg, chatbot, model_dropdown],
        outputs=chatbot
    )

demo.launch()

// Frontend web app
async function askOllama(prompt, model = "llama3.1") {
  const response = await fetch("http://localhost:11434/api/generate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: model,
      prompt: prompt,
      stream: false,
    }),
  });

  const data = await response.json();
  return data.response;
}

// Utilisation
const answer = await askOllama("Quelle est la capitale de l'Italie ?");
console.log(answer); // Rome

// Streaming
async function streamOllama(prompt, onToken) {
  const response = await fetch("http://localhost:11434/api/generate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "llama3.1",
      prompt: prompt,
      stream: true,
    }),
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split("\n").filter((line) => line.trim());

    for (const line of lines) {
      const data = JSON.parse(line);
      if (!data.done) {
        onToken(data.response);
      }
    }
  }
}

// Usage
streamOllama("Écris une histoire courte", (token) => {
  process.stdout.write(token); // Affichage progressif
});

# Par défaut : Q4_K_M (optimal)
ollama run llama3.1

# Spécifier explicitement
ollama run llama3.1:8b-instruct-q8_0  # Qualité max
ollama run llama3.1:8b-instruct-q4_K_M  # Défaut
ollama run llama3.1:8b-instruct-q2_K  # Ultra-compact

# Forcer CPU
OLLAMA_NUM_GPU=0 ollama run llama3.1

# Performance CPU typique (Intel i9-13900K, 32GB RAM)
# Llama 8B Q4 : ~5-8 tokens/sec (utilisable)
# Llama 70B Q4 : ~1-2 tokens/sec (lent mais fonctionne)

# Threads CPU (par défaut : auto)
OLLAMA_NUM_THREAD=16 ollama run llama3.1

# Contexte réduit pour économiser RAM
ollama run llama3.1 --num-ctx 2048  # Défaut : 4096

# Voir utilisation GPU en temps réel (NVIDIA)
watch -n 1 nvidia-smi

# Mac : Activity Monitor > GPU History

# Linux : htop pour CPU/RAM
htop

import ollama
from flask import Flask, request, jsonify

app = Flask(__name__)

KNOWLEDGE_BASE = """
Politique de retour : 30 jours
Frais de livraison : Gratuit au-dessus de 50€
Support : [email protected]
Horaires : Lundi-Vendredi 9h-18h
"""

@app.route("/chat", methods=["POST"])
def chat():
    user_message = request.json.get("message")

    # Prompt avec knowledge base
    prompt = f"""Contexte : Tu es un assistant customer support.

Base de connaissance :
{KNOWLEDGE_BASE}

Règles :
- Réponds uniquement basé sur la base de connaissance
- Si tu ne sais pas, redirige vers [email protected]
- Sois poli et professionnel

Client : {user_message}
Assistant :"""

    response = ollama.generate(
        model="mistral",
        prompt=prompt
    )

    return jsonify({"response": response["response"]})

if __name__ == "__main__":
    app.run(port=5000)

def generate_tests(source_code_path):
    """Générer tests unitaires avec Ollama"""
    with open(source_code_path) as f:
        code = f.read()

    prompt = f"""Génère des tests unitaires pytest pour ce code Python :

```python
{code}

### 3. Résumé automatique de documents

```python
import ollama
from pathlib import Path

def summarize_document(file_path, max_length="medium"):
    """Résumer un document texte"""
    content = Path(file_path).read_text()

    length_prompts = {
        "short": "en 3 phrases",
        "medium": "en un paragraphe",
        "long": "en plusieurs paragraphes"
    }

    prompt = f"""Résume ce document {length_prompts[max_length]} :

{content}

Résumé :"""

    response = ollama.generate(
        model="llama3.1",
        prompt=prompt
    )

    return response["response"]

# Usage
summary = summarize_document("rapport_annuel.txt", max_length="medium")
print(summary)