Ollama : créer une application web de type ChatGPT

Dans ce chapitre, nous allons créer une application de type ChatGPT : bascule multi-session, persistance de l’historique dans une base de données, une interface frontend complète et trois méthodes de déploiement.


Planification des fonctionnalités et modèle de données

Un produit de chat utilisable nécessite au moins quatre capacités : isolation multi-session, persistance de l’historique, réponses en streaming et gestion des sessions (création et suppression).

Le modèle de base de données prenant en charge ces capacités ne nécessite que deux tables :

多会话数据模型:chats 与 messages 一对多

chats stocke la liste des sessions, et messages stocke chaque message regroupé par clé étrangère. Lors du changement de session, assemblez les messages correspondants dans le tableau messages d’Ollama pour restaurer le contexte complet.

La stack technique suit le principe de dépendance minimale : Flask + sqlite3 (bibliothèque standard Python) + frontend JavaScript vanilla, zéro framework frontend.

Installez flask et l’extension ollama :

pip install flask ollama

Chargez le modèle :

ollama pull qwen3.5:4b

Backend : API complète pour les sessions et les messages

Le backend a des responsabilités claires : gérer les deux tables, et écrire chaque réponse en streaming de /api/chat dans la base de données, une par une.

Exemple

# Chemin du fichier : server.py
import json
import sqlite3
from flask import Flask, request, Response, jsonify, stream_with_context
from ollama import chat

app = Flask(__name__)
DB = 'chats.db'

def db():
    """Ouvrir une connexion à la base de données ; les lignes sont renvoyées sous forme de dictionnaires"""
    conn = sqlite3.connect(DB)
    conn.row_factory = sqlite3.Row
    return conn

def init_db():
    with db() as conn:
        conn.executescript('''
        CREATE TABLE IF NOT EXISTS chats(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );
        CREATE TABLE IF NOT EXISTS messages(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            chat_id INTEGER NOT NULL,
            role TEXT NOT NULL,
            content TEXT NOT NULL
        );
        '''
)

init_db()

# Liste des sessions
@app.get('/api/chats')
def list_chats():
    with db() as conn:
        rows = conn.execute(
            'SELECT id, title, created_at FROM chats ORDER BY id DESC'
        ).fetchall()
    return jsonify([dict(r) for r in rows])

# Créer une nouvelle session
@app.post('/api/chats')
def create_chat():
    title = (request.json or {}).get('title', 'Nouvelle session')
    with db() as conn:
        cur = conn.execute('INSERT INTO chats(title) VALUES (?)', (title,))
        return jsonify({'id': cur.lastrowid, 'title': title})

# Supprimer la session (ainsi que ses messages)
@app.delete('/api/chats/<int:cid>')
def delete_chat(cid):
    with db() as conn:
        conn.execute('DELETE FROM messages WHERE chat_id=?', (cid,))
        conn.execute('DELETE FROM chats WHERE id=?', (cid,))
    return jsonify({'ok': True})

# Lire l'historique d'une session
@app.get('/api/chats/<int:cid>/messages')
def get_messages(cid):
    with db() as conn:
        rows = conn.execute(
            'SELECT role, content FROM messages WHERE chat_id=? ORDER BY id',
            (cid,)
        ).fetchall()
    return jsonify([dict(r) for r in rows])

Cœur du backend : dialogue en streaming et réécriture de l'historique

L'interface de chat fait trois choses : récupérer l'historique et construire le contexte, générer en streaming, et réécrire la réponse complète dans la base de données.

Exemple

# Ajouter à server.py
@app.post('/api/chat')
def do_chat():
    data = request.get_json()
    cid, user_input = data['chat_id'], data['message']

    # Récupérer l’historique (y compris le message utilisateur qui vient d’être inséré) comme contexte du modèle
    with db() as conn:
        conn.execute(
            'INSERT INTO messages(chat_id, role, content) VALUES (?,?,?)',
            (cid, 'user', user_input)
        )
        history = [dict(r) for r in conn.execute(
            'SELECT role, content FROM messages WHERE chat_id=? ORDER BY id',
            (cid,)
        )]

    messages = [{'role': 'system',
                 'content': 'Vous êtes l’assistant de programmation EXAMPLE. Répondez avec précision et concision.'}]
    messages += history

    def generate():
        reply = ''
        stream = chat(model='qwen3.5:4b',
                      messages=messages, stream=True)
        for chunk in stream:
            reply += chunk.message.content
            # Envoyer chaque morceau au frontend en NDJSON
            yield json.dumps(
                {'delta': chunk.message.content},
                ensure_ascii=False) + '\n'
        # Clé : réécrire la réponse complète dans la base de données afin de constituer une mémoire persistante
        with db() as conn:
            conn.execute(
                'INSERT INTO messages(chat_id, role, content) VALUES (?,?,?)',
                (cid, 'assistant', reply))
        yield json.dumps({'done': True}, ensure_ascii=False) + '\n'

    return Response(
        stream_with_context(generate()),
        mimetype='application/x-ndjson')

# Page d'accueil : renvoyer la page frontend
@app.get('/')
def index():
    return open('index.html', encoding='utf-8').read()

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

Frontend : interface de chat en Vanilla JS

Le frontend est complet fonctionnellement et suffisamment simple : liste des sessions à gauche, zone de messages et champ de saisie à droite, avec un rendu en streaming via fetch.

Exemple

<!DOCTYPE html>
<!-- Chemin du fichier : index.html (même répertoire que server.py) -->
<html lang="zh-CN">
<head><meta charset="UTF-8"><title>ChatGPT local</title>
<style>
  body { display:flex; height:100vh; margin:0; font-family: sans-serif; }
  aside { width:220px; border-right:1px solid #ddd; overflow-y:auto; }
  aside button { display:block; width:100%; text-align:left;
                 padding:10px; border:0; background:none; cursor:pointer; }
  aside button:hover { background:#f2f2f2; }
  main { flex:1; display:flex; flex-direction:column; }
  #log { flex:1; overflow-y:auto; padding:20px; }
  .msg { margin:8px 0; line-height:1.6; white-space:pre-wrap; }
  form { display:flex; border-top:1px solid #ddd; }
  input { flex:1; padding:12px; border:0; }
</style>
</head>
<body>
<aside>
  <button onclick="newChat()">+ Nouvelle session</button>
  <div id="list"></div>
</aside>
<main>
  <div id="log"></div>
  <form id="f">
    <input id="q" placeholder="Saisissez une question, appuyez sur Entrée pour envoyer" autocomplete="off">
  </forme>
</main>
<script>
let chatId = null;
const log = document.getElementById('log');
const list = document.getElementById('list');

// Charger la liste des sessions
async function loadChats() {
  const chats = await (await fetch('/api/chats')).json();
  list.innerHTML = '';
  for (const c of chats) {
    const b = document.createElement('button');
    b.textContent = c.title;
    b.onclick = () => openChat(c.id);
    list.appendChild(b);
  }
}

// Ouvrir une session et restaurer l'historique
async function openChat(id) {
  chatId = id;
  log.innerHTML = '';
  const msgs = await (await fetch(`/api/chats/${id}/messages`)).json();
  for (const m of msgs) addMsg(m.role, m.content);
}

// Créer une nouvelle session
async function newChat() {
  const c = await (await fetch('/api/chats', {method:'POST'})).json();
  await loadChats();
  openChat(c.id);
}

// Ajouter un message à l'interface
function addMsg(role, text) {
  const div = document.createElement('div');
  div.className = 'msg';
div.textContent = (role === 'user' ? 'Vous : ' : 'Assistant : ') + text;
  log.appendChild(div);
  log.scrollTop = log.scrollHeight;
  return div;
}

// Envoyer et afficher la réponse en streaming
document.getElementById('f').onsubmit = async e => {
  e.preventDefault();
  const input = document.getElementById('q');
  const q = input.value.trim();
  if (!q || !chatId) return;
  input.value = '';
  addMsg('user', q);

  const div = addMsg('assistant', '');
  const resp = await fetch('/api/chat', {method:'POST',
    headers:{'Content-Type':'application/json'},
    body: JSON.stringify({chat_id: chatId, message: q})});
  const reader = resp.body.getReader();
  const dec = new TextDecoder();
  let buf = '';
  while (true) {
    const {done, value} = await reader.read();
    if (done) break;
    buf += dec.decode(value, {stream:true});
    const lines = buf.split('\n');
    buf = lines.pop();
    for (const line of lines) {
      if (!line) continue;
      const obj = JSON.parse(line);
      if (obj.delta) {
        div.textContent += obj.delta;
        log.scrollTop = log.scrollHeight;
      }
    }
  }
};

newChat();
loadChats();
</script>
</body>
</html>

Démarrer et accéder :

python server.py

Ouvrez http://localhost:5000 dans votre navigateur pour voir la page générée.

Vérifier trois fonctionnalités principales : l'historique est entièrement restauré lors du changement de session à gauche ; les nouvelles sessions n'interfèrent pas les unes avec les autres ; l'historique existe toujours après le redémarrage de server.py (persisté dans chats.db).


Déploiement : Trois niveaux

NiveauApprocheNotes
Utilisation personnelle localeExécuter python server.py directementÉcoute sur 127.0.0.1 par défaut, sécurisé
Partage intranetapp.run(host='0.0.0.0'), les membres accèdent à http://server-IP:5000Pas d'authentification ; assurez-vous d'ajouter Nginx Basic Auth (voir le chapitre sur le déploiement privé)
Fonctionnement à long terme sur serveur cloudenregistrement du service systemd + proxy inverse Nginx + nom de domaineExécuter d'abord ollama pull <model> sur le serveur

Utiliser systemd sur le serveur cloud pour maintenir l'application toujours en cours d'exécution :

Exemple

# Chemin du fichier : /etc/systemd/system/example-chat.service
[Unit]
Description=Application web de chat d'exemple
After=network.target ollama.service

[Service]
WorkingDirectory=/opt/example-chat
ExecStart=/usr/bin/python3 server.py
Restart=always
RestartSec=3

[Installer]
WantedBy=multi-user.target

Configurer l'exécution à long terme :

sudo systemctl daemon-reload
sudo systemctl enable --now example-chat

La liste de contrôle de sécurité complète pour un déploiement externe (port loopback, authentification par proxy inverse, auto-vérification de la surface d'exposition) se trouve dans le chapitre Sécurité et conformité ; assurez-vous de la consulter avant la mise en production.

Autres extensions