IA locale avec mémoire - sans cloud, sans abonnement, sans détour
Dans un article précédent j'ai expliqué comment utiliser Ollama sur Mac install. Ceux qui ont déjà franchi cette étape disposent maintenant d'un modèle de langage local performant - par exemple Mistral, LLaMA3 ou un autre modèle compatible auquel il est possible de s'adresser via l'API REST.
Mais de lui-même, le modèle ne "sait" que ce qui est écrit dans le prompt actuel. Il ne se souvient pas des conversations précédentes. Ce qui manque, c'est la mémoire.
C'est précisément pour cela que nous utilisons Qdrant, une base de données sémantique vectorielle moderne.
Dans cet article, je montre étape par étape
- comment installer Qdrant sur Mac install (via Docker)
- comment créer des embeddings avec Python
- comment sauvegarder, rechercher et intégrer du contenu dans le flux de travail Ollama
- et à quoi ressemble un prompt→mémoire→réponse complet
Pourquoi Qdrant ?
Qdrant ne stocke pas de textes classiques, mais des vecteurs qui représentent la signification d'un texte sous forme de code numérique. Il est ainsi possible de retrouver des contenus non seulement exacts, mais aussi sémantiquement similaires, même si les mots varient.
Ollama + Qdrant donne donc
Un modèle linguistique local avec une mémoire à long terme - sûr, contrôlable et extensible.
Conditions préalables
- Ollama est installiert et fonctionne (→ par ex. ollama run mistral)
- Docker est installiert : https://www.docker.com/products/docker-desktop
- Python 3.9+
Paquetinstallation de Qdrant :
pip install qdrant-client sentence-transformers
Démarrer Qdrant (Docker)
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant
Qdrant se met alors en marche :
http://localhost:6333 (API REST)
http://localhost:6334 (gRPC, pas nécessaire pour cet article)
Exemple en Python pour Ollama + Qdrant
Nous allons maintenant écrire un script de base simple qui :
- reçoit l'invite de l'utilisateur
- génère un vecteur d'intégration
- recherche des souvenirs sémantiquement similaires dans Qdrant
- la réponse avec contexte générée par Ollama
- enregistre la nouvelle conversation comme un souvenir
Python-Script: ollama_memory.py
import requests
from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
# Einstellungen
OLLAMA_URL = "http://localhost:11434/api/generate"
COLLECTION_NAME = "memory"
VECTOR_SIZE = 384 # für 'all-MiniLM-L6-v2'
# Lade Embedding-Modell
embedder = SentenceTransformer("all-MiniLM-L6-v2")
# Verbinde mit Qdrant
qdrant = QdrantClient(host="localhost", port=6333)
# Erstelle Collection (einmalig)
def create_collection():
if COLLECTION_NAME not in qdrant.get_collections().collections:
qdrant.recreate_collection(
collection_name=COLLECTION_NAME,
vectors_config=VectorParams(size=VECTOR_SIZE, distance=Distance.COSINE)
)
# Füge Eintrag ins Gedächtnis hinzu
def add_to_memory(text: str):
vector = embedder.encode(text).tolist()
point = PointStruct(id=hash(text), vector=vector, payload={"text": text})
qdrant.upsert(collection_name=COLLECTION_NAME, points=[point])
# Suche im Gedächtnis
def search_memory(query: str, top_k=3):
vector = embedder.encode(query).tolist()
hits = qdrant.search(
collection_name=COLLECTION_NAME,
query_vector=vector,
limit=top_k
)
return [hit.payload["text"] for hit in hits]
# Sende Anfrage an Ollama
def query_ollama(context: list[str], user_prompt: str):
prompt = "\n\n".join(context + [user_prompt])
response = requests.post(OLLAMA_URL, json={
"model": "mistral",
"prompt": prompt,
"stream": False
})
return response.json()["response"]
# Ablauf
def main():
create_collection()
print("Frage an die KI:")
user_prompt = input("> ")
context = search_memory(user_prompt)
answer = query_ollama(context, user_prompt)
print("\nAntwort von Ollama:")
print(answer.strip())
# Speichern der Konversation
full_entry = f"Frage: {user_prompt}\nAntwort: {answer.strip()}"
add_to_memory(full_entry)
if __name__ == "__main__":
main()
Indications sur la pratique
Tu peux aussi utiliser tes propres modèles d'intégration, par exemple via Ollama (par exemple nomic-embed-text) ou les modèles Hugging Face
Qdrant supporte les filtres de charge utile, les périodes et les champs (très utile pour une extension ultérieure !)
L'ID hash(text) suffit pour les tests simples, pour les applications professionnelles, tu devrais utiliser des UUIDs
L'IA locale avec mémoire - et tout ce qu'on peut en faire
Dans les chapitres précédents, j'ai montré comment créer une véritable mémoire d'IA locale sur un Mac avec Ollama et Qdrant. Une configuration qui se passe de cloud, d'abonnement et de serveurs étrangers - rapide, sûre, privée.
Mais que faire maintenant ?
Quelle est l'utilisation concrète de cette technologie ? Qu'est-ce qu'elle permet de faire, aujourd'hui, demain, après-demain ?
La réponse : beaucoup de choses.
Car ce que tu as là est bien plus qu'un chatbot. C'est une machine à penser indépendante de la plate-forme et dotée d'une mémoire à long terme. Et cela ouvre des portes.
🔍 1. base de connaissances personnelle
Tu peux utiliser Ollama + Qdrant comme ta mémoire personnelle à long terme.
Documents, notes de conversation, idées - tout ce que tu lui dis peut être stocké sémantiquement et retrouvé.
exemple :
"Quelle était mon idée d'entreprise de jeudi dernier ?"
"Quels clients ont demandé une mise à niveau en mars ?"
Au lieu de chercher dans des dossiers, tu demandes simplement à ton système. Particulièrement intéressant : cela fonctionne même si la question n'est pas précise, car Qdrant effectue une recherche sémantique et pas seulement par mots-clés.
📄 2. journalisation et résumé automatiques
En combinaison avec une entrée audio ou texte, le système peut enregistrer en continu :
- Notes de discussion en réunion
- Appels avec les clients
- Protocoles journaliers ou déroulement de projets
Ces données sont automatiquement introduites dans la mémoire Qdrant et peuvent ainsi être interrogées ultérieurement, comme un assistant :
"Qu'a dit M. Meier sur la livraison, déjà ?"
"Comment s'est déroulé le projet XY ?"
🧠 3. coach personnel ou assistant de journal intime
En notant régulièrement tes pensées, tes humeurs ou tes décisions, tu peux créer un compagnon de réflexion :
"Quelle a été ma plus grande avancée ce mois-ci ?"
"Comment ai-je réagi aux échecs à l'époque ?"
Le système apprend à te connaître au fil du temps - et devient un véritable miroir, pas seulement un chatbot.
💼 4. applications commerciales avec FileMaker
Ceux qui, comme moi, utilisent FileMaker, peuvent directement connecter cette configuration :
- Envoyer des invites depuis FileMaker
- Récupérer et enregistrer automatiquement les réponses
- Contrôler les accès à la mémoire directement via l'API REST ou un script shell
Il en résulte une combinaison extrêmement puissante :
- FileMaker = Frontend, interface utilisateur, centrale de commande
- Ollama = Intelligence linguistique
- Qdrant = mémoire sémantique à long terme
Le résultat : un véritable composant d'IA pour les solutions FileMaker, local, sécurisé, personnalisé.
🛠️ 5. Soutien au quotidien : souvenirs, idées, recommandations
"Rappelle-moi cette idée la semaine prochaine"
"Quels livres t'ai-je déjà recommandés ?"
"Que pourrais-je proposer ensuite à M. Müller ?"
Avec une logique de stockage ciblée (horodatage, catégories, utilisateurs), tu peux structurer la mémoire de manière ciblée et l'utiliser dans de nombreux domaines de la vie et de l'entreprise.
🤖 6. base d'un système d'agents
Pour ceux qui voient plus loin, cette configuration permet également de construire des systèmes de type agent :
- L'IA prend en charge des tâches simples
- L'IA reconnaît des modèles dans le temps
- L'IA donne des indications proactives
exemple :
"Tu as posé 4 fois la même question cette semaine - veux-tu enregistrer une note à ce sujet ?"
"Un nombre remarquablement élevé de clients ont mentionné ce produit - veux-tu que je te fasse un résumé ?"
🌐 7. intégration avec d'autres outils
Le système peut être facilement relié à d'autres outils :
- Neo4jpour représenter graphiquement les relations sémantiques
- Fichiers & PDFpour indexer automatiquement le contenu
- Analyseur de courrierpour analyser et mémoriser les e-mails
- Assistants vocauxpour interagir par la voix
🔐 8. tout reste local - et sous contrôle
Le plus grand avantage : tu décides de ce qui doit être sauvegardé. Tu décides de la durée de stockage. Et : cela ne quitte jamais ton ordinateur si tu ne le souhaites pas. Dans un monde où beaucoup s'en remettent aveuglément à l'IA en nuage, c'est un contrepoids puissant - notamment pour les indépendants, les développeurs, les auteurs, les entrepreneurs.
Dernière enquête sur l'utilisation des systèmes d'IA locaux
Ollama + Apprivoiser Qdrant : Comment donner une structure, des règles et un réglage fin à l'IA locale
Celui qui s'est donné la peine de Ollama et de Qdrant en local sur son Mac a déjà fait un grand travail. Tu as maintenant
- Une IA linguistique locale
- Une mémoire sémantique
- Et un pipeline fonctionnel qui mappe prompt → mémoire → Ollama → réponse
Mais ceux qui l'utilisent s'aperçoivent vite qu'il faut des règles. De la structure. De l'ordre.
Car sans commande, ton assistant devient vite un bavard qui retient trop de choses, se répète sans cesse ou fait appel à des souvenirs non pertinents.
🧭 Que manque-t-il encore ?
Un orchestre a aussi un chef d'orchestre. Et c'est précisément ta mission à présent : piloter au lieu de simplement utiliser.
Module 1 : Un "routeur" pour la logique de la mémoire
Au lieu de tout sauvegarder ou de tout rechercher, tu devrais d'abord décider si quelque chose doit être sauvegardé ou chargé. Cela peut se faire par exemple avec un simple routeur de pertinence que tu places entre l'invite et la mémoire :
ExempleVérifier la pertinence par prompt à Ollama lui-même
def is_relevant_for_memory(prompt, response):
prüf_prompt = f"""
Nutzer hat gefragt: "{prompt}"
Die KI hat geantwortet: "{response}"
Sollte man sich diesen Dialog langfristig merken? Antworte nur mit 'Ja' oder 'Nein'.
"""
result = query_ollama([], prüf_prompt).strip().lower()
return result.startswith("ja")
Tu donnes donc toi-même à Ollama la tâche d'évaluer sa réponse - et ce n'est que si elle est jugée pertinente que tu l'enregistres dans Qdrant.
Module 2 : Exclure les messages plus anciens (limitation du contexte)
C'est justement lors de longues sessions que cela devient problématique lorsque d'anciens messages reviennent sans cesse dans le contexte. Le modèle n'oublie pas - il s'éparpille.
Solution: limiter la fenêtre de contexte.
Tu peux le faire de deux manières :
Méthode 1: limite le nombre de résultats
context = search_memory(user_prompt, top_k=3)
Ici, seul ce qui est sémantiquement pertinent est chargé - pas tout.
Méthode 2: Limite le temps
# Nur Nachrichten der letzten 7 Tage now = datetime.utcnow() filter = Filter( must=[ FieldCondition(key="timestamp", range=Range(gte=now - timedelta(days=7))) ] )
Tu peux donc "couper" dans le temps si le système s'étend trop loin dans le passé.
Module 3 : Introduire les poids contextuels et les labels
Toutes les entrées de la mémoire n'ont pas la même valeur. Tu peux leur donner du poids ou des catégories :
- Fixe (p. ex. "L'utilisateur s'appelle Markus")
- Temporaire (p. ex. "Aujourd'hui, c'est mardi")
- En situation (par exemple, "Chat d'aujourd'hui 10h30")
Qdrant supporte ce que l'on appelle les charges utiles, c'est-à-dire des informations supplémentaires par entrée. Cela te permet de filtrer ou d'établir des priorités par la suite.
Module 4 : Réglage fin via le prompt
Le prompt lui-même est une puissante unité de contrôle.
Voici quelques astuces pour l'utiliser et rendre Ollama plus intelligent :
Exemple d'invite avec des instructions :
Tu es un assistant local avec une mémoire sémantique. Si tu trouves plusieurs rappels, n'utilise que les trois plus pertinents. Ne te réfère pas à des informations datant de plus de 10 jours, à moins qu'elles ne soient explicitement marquées. Ignore les rappels triviaux comme "bonjour" ou "merci". Réponds de manière précise et dans le style d'un conseiller expérimenté.
Tu peux ainsi effectuer toi-même des réglages fins directement dans le prompt - sans nouveaux modèles, sans formation.
Et : tu peux générer l'invite de manière dynamique - selon la situation.
Module 5 : Hygiène de la mémoire
Quand la mémoire grandit, elle devient confuse.
Un simple script de maintenance qui supprime les contenus non pertinents ou en double vaut son pesant d'or.
exemple :
"Oublie tout ce qui a trait au 'temps'".
"Supprimer les entrées datant de plus de 3 mois et qui n'ont jamais été consultées".
Qdrant supporte cela via l'API - et tu peux l'automatiser, par exemple une fois par semaine.
Module 6 : FileMaker comme pupitre de commande
Si tu travailles - comme moi - avec FileMaker, tu peux contrôler tout cela à distance via l'API REST :
- Envoyer un prompt
- Récupérer le contexte
- Recevoir une réponse
- Faire procéder à une évaluation
- Enregistrer ou faire oublier
Pour cela, tu n'as besoin que d'un petit module REST dans FileMaker (Insert from URL avec JSON) et de quelques scripts.
Résultat : une interface qui te permet de contrôler ton IA comme un carnet de notes vivant - mais avec intelligence.
🔚 Conclusion : la qualité de l'IA dépend de son leadership
Ollama est puissant. Qdrant est flexible. Mais sans règles claires, les deux deviennent un amas de données non structurées. L'art ne consiste pas à tout stocker - mais à ne garder à disposition que ce qui est pertinent et à penser de manière ciblée au lieu de simplement se souvenir.