Initiation a l'IA

1. Qu'est-ce que l'IA ?

L'intelligence artificielle, c'est quoi au juste ?

Imagine que tu veux apprendre a un enfant a reconnaitre des fruits. Tu lui montres 1000 pommes, 1000 oranges, 1000 bananes. Au debut, il se trompe. Tu corriges. Petit a petit, il apprend les motifs : la pomme est ronde et rouge, l'orange est orange et pele, la banane est longue et jaune.

L'IA fait exactement la meme chose. Sauf qu'au lieu d'un enfant, c'est un programme informatique. Et au lieu de "voir" des fruits, il "voit" des nombres.

IA, Machine Learning, Deep Learning : la difference

Ces trois termes sont souvent utilises de maniere interchangeable, mais ils s'emboitent :

┌─────────────────────────────────────────────────────────────┐
│                    INTELLIGENCE ARTIFICIELLE                  │
│  Tout programme qui simule une intelligence humaine          │
│  (chatbot, pathfinding jeu video, recommandation)            │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │                  MACHINE LEARNING                        │  │
│  │  Programmes qui apprennent a partir de donnees           │  │
│  │  (regression, arbres de decision, spam filter)           │  │
│  │  ┌───────────────────────────────────────────────────┐  │  │
│  │  │               DEEP LEARNING                        │  │  │
│  │  │  Reseaux de neurones profonds                      │  │  │
│  │  │  ChatGPT, Claude, reconnaissance d'images          │  │  │
│  │  └───────────────────────────────────────────────────┘  │  │
│  └──────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

Ce que l'IA peut faire

• Reconnaissance d'images — Identifier des objets, des visages, des ecritures
• Traitement du langage — Traduire, resumer, generer du texte
• Recommandation — Netflix, Spotify, YouTube te suggerent des contenus
• Prediction — Prix immo, meteo, risques
• Generation — Creer des images, du texte, de la musique

Ce que l'IA NE peut PAS faire

• Comprendre vraiment — L'IA manipule des symboles, elle ne "comprend" pas
• Avoir une conscience — Pas de sentiments, pas de volonte propre
• Raisonner comme un humain — Pas de bon sens, pas d'intuition
• Apprendre sans donnees — Il faut des masses de donnees

2. Les mots qu'il faut connaitre

Avant de manipuler l'IA, voici le vocabulaire de base. Pas de jargon, juste les mots qu'on croise partout.

3. Les types de modeles

Tous les modeles ne font pas la meme chose. Voici les grandes familles :

Pour ce tuto, on va se concentrer sur les LLM et les embeddings, parce que c'est ce qui couvre 90% des usages perso.

4. Premier usage : parler a un LLM

On commence par le plus simple : installer un modele en local et lui parler.

Installer Ollama

Ollama est un outil qui lance des modeles d'IA en local, gratuitement, sans compte.

# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh

# Windows : telecharger https://ollama.com/download
# Verifier l'installation
ollama --version

Lancer un premier modele

Ollama telecharge et lance un modele en une seule commande. On commence avec un petit modele rapide :

# Lancer llama3.2 (3 milliards de parametres, ~2 Go)
ollama run llama3.2

# Autres modeles interessants pour debuter :
# ollama run phi3        # Tres petit, tres rapide
# ollama run mistral     # Bon generaliste
# ollama run llama3.2:1b # Ultra leger pour tests

La premiere fois, Ollama telecharge le modele (2 Go pour llama3.2, quelques minutes). Ensuite, tu te retrouves dans un chat direct dans le terminal :

$ ollama run llama3.2
>>> Bonjour, tu peux te presenter ?
Bonjour ! Je suis Llama 3.2, un modele de langage entraine par Meta...

>>> Resume-moi ce texte en 3 points :
>>> L'intelligence artificielle est un domaine de l'informatique...
1. L'IA simule l'intelligence humaine
2. Elle apprend a partir de donnees
3. Elle ne "comprend" pas, elle predit

Le systeme de prompt

Un prompt, c'est l'instruction que tu donnes au modele. La qualite de la reponse depend directement de la qualite du prompt. Quelques exemples concrets :

# Traduction
>>> Traduis en anglais : "Le chat dort sur le canape"
"The cat is sleeping on the couch"

# Brainstorm
>>> Donne-moi 5 idees de noms pour un site de streaming
1. CineSphere
2. StreamHub
3. ...

# Code
>>> Ecris une fonction JavaScript qui verifie si un nombre est premier
function isPrime(n) { ... }

# Role
>>> Tu es un professeur de maths. Explique-moi les fractions
comme si j'avais 10 ans.

Appeler un modele en code

Ollama expose une API HTTP sur le port 11434. Tu peux l'appeler depuis n'importe quel langage :

// Appeler un modele Ollama en JavaScript
const OLLAMA_URL = 'http://localhost:11434';
const MODEL = 'llama3.2';

async function chat(prompt) {
  const response = await fetch(`${OLLAMA_URL}/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;
}

// Test
const reponse = await chat('Resume en 1 phrase : l\'IA est un outil statistique.');
console.log(reponse);

# Appeler un modele Ollama en Python
import requests

OLLAMA_URL = 'http://localhost:11434'
MODEL = 'llama3.2'

def chat(prompt):
    response = requests.post(f'{OLLAMA_URL}/api/generate', json={
        'model': MODEL,
        'prompt': prompt,
        'stream': False
    })
    return response.json()['response']

# Test
reponse = chat("Resume en 1 phrase : l'IA est un outil statistique.")
print(reponse)

5. Aller plus loin : embeddings et RAG

Jusqu'ici, on a parle a un modele "vide" : il ne connait que ce qu'il a appris pendant son entrainement. Mais si tu veux qu'il reponde a partir de tes documents (tes PDF, tes notes, ta doc) ? C'est la qu'interviennent les embeddings et le RAG.

Qu'est-ce qu'un embedding ?

Un embedding, c'est une representation numerique du "sens" d'un texte. On donne une phrase a un modele, il renvoie un vecteur de nombres (souvent 768 ou 1024 nombres). Deux phrases qui veulent dire la meme chose auront des vecteurs proches.

TEXTE                           EMBEDDING (vecteur de nombres)

"Le chat dort"        ──▶  [0.12, -0.34, 0.56, 0.23, ...]
"Le chat fait une"    ──▶  [0.11, -0.32, 0.55, 0.22, ...]   ← tres similaire
"sieste"
"La voiture roule"    ──▶  [-0.45, 0.23, 0.12, -0.67, ...]  ← different

On peut comparer deux embeddings avec une similarite cosinus : plus le resultat est proche de 1, plus les textes sont proches en sens. Pas besoin de comprendre la formule, juste le principe : plus c'est proche de 1, plus ca veut dire la meme chose.

Qu'est-ce que le RAG ?

RAG = Retrieval Augmented Generation. En clair :

1. On decoupe nos documents en petits morceaux
2. On calcule l'embedding de chaque morceau et on les stocke
3. Quand on pose une question, on calcule l'embedding de la question
4. On cherche les morceaux les plus proches de la question
5. On donne ces morceaux au LLM avec la question, et il repond

MES DOCUMENTS                QUESTION
   │                            │
   ▼                            ▼
[Embeddings]               [Embedding de la question]
   │                            │
   └─────────┬──────────────────┘
             ▼
   [Morceaux les plus proches]
             │
             ▼
   ┌─────────────────────┐
   │  LLM + contexte      │ ──▶ Reponse basee sur MES docs
   │  "Voici mes notes,  │
   │   reponds a la       │
   │   question"          │
   └─────────────────────┘

C'est exactement comme ca que fonctionne ChatGPT quand tu lui donnes un fichier : il ne "lit" pas ton fichier a chaque message, il cherche les parties pertinentes et les donne au modele.

Mini-projet : RAG sur un PDF

On va poser des questions sur le contenu d'un PDF. Pour rester simple, on prend un PDF texte (pas un scan). Le principe :

D'abord, installe le modele d'embeddings :

ollama pull nomic-embed-text

Ensuite, le code complet :

// RAG sur un PDF en JavaScript
// Dependances : npm install pdf-parse

import fs from 'node:fs/promises';

const OLLAMA_URL = 'http://localhost:11434';
const EMBED_MODEL = 'nomic-embed-text';
const LLM_MODEL = 'llama3.2';

// 1. Lire et decouper un PDF en morceaux
import pdf from 'pdf-parse';
const buffer = await fs.readFile('mon-document.pdf');
const data = await pdf(buffer);
const text = data.text;

// Decoupage simple : morceaux de 500 caracteres
function chunk(text, size = 500) {
  const chunks = [];
  for (let i = 0; i < text.length; i += size) {
    chunks.push(text.slice(i, i + size));
  }
  return chunks;
}

const chunks = chunk(text);
console.log(`${chunks.length} morceaux extraits`);

// 2. Calculer l'embedding de chaque morceau
async function getEmbedding(text) {
  const response = await fetch(`${OLLAMA_URL}/api/embeddings`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: EMBED_MODEL, prompt: text })
  });
  return (await response.json()).embedding;
}

const embeddings = [];
for (const c of chunks) {
  embeddings.push(await getEmbedding(c));
}

// 3. Similarite cosinus
function cosine(a, b) {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    na += a[i] * a[i];
    nb += b[i] * b[i];
  }
  return dot / (Math.sqrt(na) * Math.sqrt(nb));
}

// 4. Poser une question
async function ask(question) {
  const qEmb = await getEmbedding(question);

  // Trouver les 3 morceaux les plus proches
  const scores = embeddings.map((emb, i) => ({
    text: chunks[i],
    score: cosine(qEmb, emb)
  })).sort((a, b) => b.score - a.score).slice(0, 3);

  const context = scores.map(s => s.text).join('\n\n');

  // Donner le contexte au LLM
  const prompt = `Reponds a la question en te basant sur ce contexte. Si la reponse n'est pas dans le contexte, dis-le.

Contexte :
${context}

Question : ${question}`;

  const response = await fetch(`${OLLAMA_URL}/api/generate`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: LLM_MODEL, prompt, stream: false })
  });
  return (await response.json()).response;
}

// Test
const reponse = await ask('Quelle est l'idee principale du document ?');
console.log(reponse);

# RAG sur un PDF en Python
# Dependances : pip install pymupdf requests

import requests
import fitz  # pymupdf

OLLAMA_URL = 'http://localhost:11434'
EMBED_MODEL = 'nomic-embed-text'
LLM_MODEL = 'llama3.2'

# 1. Lire et decouper un PDF
doc = fitz.open('mon-document.pdf')
text = ''.join(page.get_text() for page in doc)

def chunk(text, size=500):
    return [text[i:i+size] for i in range(0, len(text), size)]

chunks = chunk(text)
print(f'{len(chunks)} morceaux extraits')

# 2. Embeddings
def get_embedding(text):
    response = requests.post(f'{OLLAMA_URL}/api/embeddings', json={
        'model': EMBED_MODEL, 'prompt': text
    })
    return response.json()['embedding']

embeddings = [get_embedding(c) for c in chunks]

# 3. Similarite cosinus
def cosine(a, b):
    dot = sum(x*y for x, y in zip(a, b))
    na = sum(x**2 for x in a) ** 0.5
    nb = sum(x**2 for x in b) ** 0.5
    return dot / (na * nb)

# 4. Poser une question
def ask(question):
    q_emb = get_embedding(question)

    scores = sorted(
        [{'text': chunks[i], 'score': cosine(q_emb, embeddings[i])}
         for i in range(len(chunks))],
        key=lambda x: x['score'], reverse=True
    )[:3]

    context = '\n\n'.join(s['text'] for s in scores)

    prompt = f"""Reponds a la question en te basant sur ce contexte. Si la reponse n'est pas dans le contexte, dis-le.

Contexte :
{context}

Question : {question}"""

    response = requests.post(f'{OLLAMA_URL}/api/generate', json={
        'model': LLM_MODEL, 'prompt': prompt, 'stream': False
    })
    return response.json()['response']

# Test
reponse = ask("Quelle est l'idee principale du document ?")
print(reponse)

6. Creer une API IA

Maintenant qu'on sait appeler un modele, on peut le servir en HTTP pour que d'autres apps s'y connectent. On construit une mini-API avec deux endpoints : /chat et /embed.

// api-ia.js - Mini API IA avec Express
// npm install express
import express from 'express';

const app = express();
app.use(express.json());

const OLLAMA_URL = 'http://localhost:11434';

// POST /chat { "prompt": "..." }
app.post('/chat', async (req, res) => {
  try {
    const response = await fetch(`${OLLAMA_URL}/api/generate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: 'llama3.2',
        prompt: req.body.prompt,
        stream: false
      })
    });
    const data = await response.json();
    res.json({ reponse: data.response });
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// POST /embed { "text": "..." }
app.post('/embed', async (req, res) => {
  try {
    const response = await fetch(`${OLLAMA_URL}/api/embeddings`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: 'nomic-embed-text',
        prompt: req.body.text
      })
    });
    const data = await response.json();
    res.json({ embedding: data.embedding });
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// Healthcheck
app.get('/health', (req, res) => res.json({ status: 'ok' }));

app.listen(3000, () => console.log('API IA sur http://localhost:3000'));

# api_ia.py - Mini API IA avec Flask
# pip install flask requests
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)
OLLAMA_URL = 'http://localhost:11434'

# POST /chat
@app.post('/chat')
def chat():
    prompt = request.json.get('prompt', '')
    response = requests.post(f'{OLLAMA_URL}/api/generate', json={
        'model': 'llama3.2',
        'prompt': prompt,
        'stream': False
    })
    return jsonify({'reponse': response.json()['response']})

# POST /embed
@app.post('/embed')
def embed():
    text = request.json.get('text', '')
    response = requests.post(f'{OLLAMA_URL}/api/embeddings', json={
        'model': 'nomic-embed-text',
        'prompt': text
    })
    return jsonify({'embedding': response.json()['embedding']})

# Healthcheck
@app.get('/health')
def health():
    return jsonify({'status': 'ok'})

if __name__ == '__main__':
    app.run(port=3000)

On la lance en arriere-plan, on la teste :

# Lancer
node api-ia.js   # ou python api_ia.py

# Tester
curl -X POST http://localhost:3000/chat \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Bonjour, qui es-tu ?"}'

7. Limites, pieges et bonnes pratiques

L'IA n'est pas magique. Voici les pieges qu'il faut connaitre avant de l'utiliser serieusement.

Hallucinations

Un LLM predit le mot suivant. Il n'a aucun mecanisme pour dire "je ne sais pas". Si on lui demande un fait qu'il ne connait pas, il invente un truc plausible. C'est ce qu'on appelle une hallucination.

Comment mitiger :

• Demander explicitement "Si tu ne sais pas, dis-le"
• Utiliser le RAG (section 5) pour limiter la reponse a un contexte
• Verifier les faits critiques aupres d'une source fiable

Biais

Un modele apprend sur des donnees humaines. Les donnees humaines ont des biais (genre, origine, culture). Le modele peut reproduire ces biais dans ses reponses.

Couts et ressources

Confidentialite

Si tu envoies des donnees sensibles a une API commerciale (OpenAI, Anthropic, Google), ces donnees transitent par leurs serveurs. Pour des documents prives, preferer un modele local (Ollama) ou un provider qui ne stocke pas les donnees.

Quand NE PAS utiliser l'IA

• Calculs precis — Les LLM sont mauvais en maths. Utilise un vrai outil de calcul.
• Faits verifies — Une API dediee (Wikipedia, meteo, bourse) est plus fiable.
• Decisions critiques — Medical, juridique, financier : l'IA assiste, elle ne decide pas.
• Code en production sans relecture — L'IA genere du code plausible mais parfois faux.

8. Pour aller plus loin

Sur ce site

• Installer OpenWebUI — Interface graphique type ChatGPT pour tes modeles locaux
• Installer OpenCode — Agent IA qui code avec toi dans le terminal
• Installer n8n — Automatiser des taches avec l'IA dans des workflows
• Maitriser les donnees — Construire une base, un moteur de recherche et un pipeline ETL
• Construire un serveur web — La base pour servir une API en Node.js

Modeles a essayer avec Ollama

• ollama run llama3.2 — Generaliste equilibre, bon pour debuter
• ollama run phi3 — Tres petit, tres rapide, suffisant pour beaucoup de taches
• ollama run mistral — Bon generaliste francophone
• ollama run qwen2.5 — Excellent en code
• ollama run llava — Decode et decrit des images
• ollama pull nomic-embed-text — Modele d'embeddings pour le RAG

Projets a faire

• Un chatbot sur tes notes de cours (RAG sur Markdown)
• Un resumeur de longs emails
• Un traducteur multilingue avec API
• Un assistant qui repond a des questions sur un manuel PDF
• Un generateur de descriptions de films a partir de leur titre

Ressources externes

• Ollama Library — Catalogue des modeles disponibles
• Blog Ollama — Tutoriels et nouveautes
• Hugging Face Course — Cours gratuit sur le NLP et les transformers
• Prompt Engineering Guide — L'art de bien poser ses questions a l'IA