Memori - Présentation détaillée du moteur de mémoire IA open source

Aperçu du projet

Memori est un moteur de mémoire open source natif SQL, conçu pour les grands modèles linguistiques (LLM), les agents IA et les systèmes multi-agents. Il permet à tout LLM d'acquérir une capacité de mémoire persistante et interrogeable en une seule ligne de code, en stockant les données de mémoire dans une base de données SQL standard.

Caractéristiques principales :

• Intégration en une seule ligne de code via memori.enable()
• Les données de mémoire sont stockées dans des bases de données SQL standard (SQLite, PostgreSQL, MySQL), l'utilisateur en a la pleine propriété et le contrôle.
• L'IA peut se souvenir des conversations, apprendre des interactions et maintenir le contexte sur plusieurs sessions.

Pourquoi choisir Memori ?

1. Intégration en une seule ligne de code

Prend en charge OpenAI, Anthropic, LiteLLM, LangChain et tout autre framework LLM, l'intégration est extrêmement simple.

2. Stockage natif SQL

• Données de mémoire portables, interrogeables et auditables
• Stockées dans une base de données que vous contrôlez entièrement
• Pas besoin de bases de données vectorielles complexes

3. Économies de coûts de 80 à 90 %

Pas besoin de bases de données vectorielles coûteuses, ce qui réduit considérablement les coûts d'exploitation.

4. Aucun verrouillage fournisseur

Vous pouvez exporter la mémoire au format SQLite et la migrer n'importe où, n'importe quand.

5. Gestion intelligente de la mémoire

• Extraction automatique d'entités
• Mappage des relations
• Priorisation du contexte

Démarrage rapide

Installation

pip install memorisdk

Utilisation de base

from memori import Memori
from openai import OpenAI

# Initialisation
memori = Memori(conscious_ingest=True)
memori.enable()
client = OpenAI()

# Première conversation
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I'm building a FastAPI project"}]
)

# Conversations suivantes - Memori fournit automatiquement le contexte
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Help me add authentication"}]
)
# Le LLM connaîtra automatiquement les informations de votre projet FastAPI

Bases de données prises en charge

Memori prend en charge toute base de données SQL standard :

Base de données	Exemple de chaîne de connexion
SQLite	sqlite:///my_memory.db
PostgreSQL	postgresql://user:pass@localhost/memori
MySQL	mysql://user:pass@localhost/memori
Neon	postgresql://user:pass@ep-*.neon.tech/memori
Supabase	postgresql://postgres:pass@db.*.supabase.co/postgres

Frameworks LLM pris en charge

Grâce au système de rappel natif de LiteLLM, Memori prend en charge tous les frameworks majeurs :

Framework	Statut	Utilisation
OpenAI	✓ Support natif	from openai import OpenAI
Anthropic	✓ Support natif	from anthropic import Anthropic
LiteLLM	✓ Support natif	from litellm import completion
LangChain	✓ Pris en charge	Intégration via LiteLLM
Azure OpenAI	✓ Pris en charge	Configuration via ProviderConfig.from_azure()
100+ modèles	✓ Pris en charge	Tout fournisseur compatible LiteLLM

Options de configuration

Configuration de la base de données

from memori import Memori

memori = Memori(
    database_connect="postgresql://user:pass@localhost/memori",
    conscious_ingest=True,  # Mémoire de travail à court terme
    auto_ingest=True,       # Recherche dynamique à chaque requête
    openai_api_key="sk-..."
)
memori.enable()

Modes de mémoire

Mode Conscious - Injection de mémoire de travail unique

memori = Memori(conscious_ingest=True)

Mode Auto - Recherche dynamique à chaque requête

memori = Memori(auto_ingest=True)

Mode Combiné - Les deux

memori = Memori(conscious_ingest=True, auto_ingest=True)

Configuration des variables d'environnement

from memori import Memori, ConfigManager

config = ConfigManager()
config.auto_load()  # Charge depuis les variables d'environnement ou un fichier de configuration
memori = Memori()
memori.enable()

Définir les variables d'environnement :

export MEMORI_DATABASE__CONNECTION_STRING="postgresql://..."
export MEMORI_AGENTS__OPENAI_API_KEY="sk-..."
export MEMORI_MEMORY__NAMESPACE="production"

Comment ça marche

Memori fonctionne en interceptant les appels LLM - en injectant le contexte avant l'appel et en enregistrant les informations après l'appel :

Avant l'appel (injection de contexte)

1. Votre application appelle client.chat.completions.create(messages=[...])
2. Memori intercepte cet appel de manière transparente
3. L'Agent de récupération (mode auto) ou l'Agent Conscious (mode conscious) récupère les souvenirs pertinents
4. Le contexte est injecté dans les messages avant d'être envoyé au fournisseur LLM

Après l'appel (enregistrement)

1. Le fournisseur LLM renvoie une réponse
2. L'Agent de mémoire extrait les entités, les classe (faits, préférences, compétences, règles, contexte)
3. La conversation est stockée dans la base de données SQL, avec un index de recherche en texte intégral
4. La réponse originale est renvoyée à votre application

Traitement en arrière-plan (toutes les 6 heures)

• L'Agent Conscious analyse les schémas et promeut les souvenirs importants du stockage à long terme vers le stockage à court terme

Exemples de scénarios d'application

Exemples de base

• Utilisation de base - Configuration simple de la mémoire
• Assistant personnel - Assistant IA avec mémoire
• Récupération de mémoire - Appel de fonction
• Configuration avancée - Paramètres pour l'environnement de production

Scénarios multi-utilisateurs

• Multi-utilisateurs simple - Isolation de la mémoire utilisateur
• Application FastAPI multi-utilisateurs - API REST avec Swagger

Exemples d'intégration de frameworks

Memori fournit des exemples d'intégration avec plusieurs frameworks IA populaires :

• Agno
• AWS Strands
• Azure AI Foundry
• AutoGen
• CamelAI
• CrewAI
• Digital Ocean AI
• LangChain
• OpenAI Agent
• Swarms

Démos en ligne

• Assistant de journal personnel - Application Streamlit disponible en ligne
• Agent assistant de recherche - Outil de recherche disponible en ligne

Architecture technique

Memori adopte une conception d'architecture en couches :

1. Couche d'interception - Intercepte de manière transparente les appels d'API LLM
2. Couche de récupération - Récupère intelligemment le contexte de mémoire pertinent
3. Couche de stockage - Stockage persistant dans une base de données SQL
4. Couche d'analyse - Analyse en arrière-plan et optimisation de la mémoire

Pour une documentation architecturale détaillée, veuillez consulter architecture.md dans la documentation officielle.

Édition Entreprise (Memori v3)

Memori ouvre un petit groupe de test privé pour la version v3. Si vous souhaitez en savoir plus et accéder en avant-première à la nouvelle architecture de mémoire pour l'IA d'entreprise, vous pouvez rejoindre leur programme de test.

Communauté et support

• Documentation : https://memorilabs.ai/docs
• Communauté Discord : https://discord.gg/abD4eGym6v
• Problèmes GitHub : https://github.com/GibsonAI/memori/issues

Guide de contribution

Memori accueille les contributions de la communauté ! Le projet fournit un guide de contribution détaillé, incluant :

• Configuration de l'environnement de développement
• Style et standards de code
• Soumission de Pull Requests
• Signalement de problèmes

Licence Open Source

Licence Apache 2.0

Résumé

Memori est une solution de mémoire IA puissante et facile à utiliser, particulièrement adaptée pour :

• Les développeurs qui ont besoin d'ajouter des capacités de mémoire à leurs applications LLM
• Les équipes qui construisent des assistants IA multi-sessions
• Les projets qui cherchent à réduire les coûts des bases de données vectorielles
• Les entreprises qui souhaitent un contrôle total sur les données de mémoire de leur IA

Grâce à sa conception basée sur le stockage natif SQL et l'intégration en une seule ligne de code, Memori réduit considérablement la barrière et les coûts liés à l'ajout de fonctionnalités de mémoire aux applications IA.