Présentation détaillée du projet MemoRizz

Vue d'ensemble du projet

MemoRizz est une bibliothèque de gestion de mémoire Python conçue spécifiquement pour les applications d'IA, offrant aux agents d'IA des capacités de stockage d'informations persistantes, sensibles au contexte et interrogeables sémantiquement. Grâce à l'intégration transparente de MongoDB et des technologies d'intégrations vectorielles, ce projet confère aux agents des fonctions cognitives complexes, y compris le suivi de l'historique des conversations, la gestion de l'utilisation des outils et le maintien d'un rôle cohérent.

⚠️ Avertissement important : MemoRizz est une bibliothèque expérimentale, destinée uniquement à des fins éducatives. Son utilisation n'est pas recommandée dans des environnements de production ou avec des données sensibles.

Fonctionnalités clés

🧠 Mémoire persistante

• Permet aux agents d'IA de conserver leur mémoire entre les sessions
• Prend en charge le stockage et la récupération d'informations à long terme
• Gestion de la mémoire sensible au contexte

🔍 Recherche sémantique

• Utilise le langage naturel pour trouver des informations pertinentes
• Recherche de similarité basée sur les intégrations vectorielles
• Intégration de la recherche vectorielle MongoDB Atlas

🛠️ Intégration d'outils

• Découverte et exécution automatiques de fonctions
• Convertit les fonctions Python en outils appelables par les LLM
• Indexation sémantique et découverte par langage naturel des outils

👤 Système de rôles

• Crée des rôles d'agent spécialisés et cohérents
• Personnalise le comportement et le style de réponse de l'agent
• Définition du contexte et des objectifs du rôle

📊 Recherche vectorielle

• Récupération efficace via la recherche vectorielle MongoDB Atlas
• Intégration et indexation automatiques des informations stockées
• Prend en charge la classification de plusieurs types de mémoire

Architecture système

┌─────────────────┐
│ MemAgent        │ ← Interface d'agent de haut niveau
├─────────────────┤
│ Persona         │ ← Personnalité et comportement de l'agent
├─────────────────┤
│ Toolbox         │ ← Enregistrement et découverte de fonctions
├─────────────────┤
│ Memory Provider │ ← Couche d'abstraction du stockage
├─────────────────┤
│ Vector Search   │ ← Similarité sémantique et récupération
├─────────────────┤
│ MongoDB         │ ← Backend de stockage persistant
└─────────────────┘

Prérequis d'installation

• Python 3.7+
• Compte MongoDB Atlas (ou MongoDB local avec recherche vectorielle)
• Clé API OpenAI (pour les intégrations et les fonctionnalités LLM)

Méthode d'installation

pip install memorizz

Exemple d'utilisation de base

1. Configuration de base de l'agent

import os
from memorizz.memory_provider.mongodb.provider import MongoDBConfig, MongoDBProvider
from memorizz.memagent import MemAgent
from memorizz.llms.openai import OpenAI

# Définir la clé API
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# Configurer le fournisseur de mémoire MongoDB
mongodb_config = MongoDBConfig(uri="your-mongodb-atlas-uri")
memory_provider = MongoDBProvider(mongodb_config)

# Créer un MemAgent
agent = MemAgent(
    model=OpenAI(model="gpt-4"),
    instruction="You are a helpful assistant with persistent memory.",
    memory_provider=memory_provider
)

# Commencer la conversation - l'agent conservera sa mémoire entre les sessions
response = agent.run("Hello! My name is John and I'm a software engineer.")
print(response)

# Plus tard, dans une autre session...
response = agent.run("What did I tell you about myself?")
print(response)  # L'agent se souvient que John est ingénieur logiciel

2. Utilisation du système de rôles

from memorizz.persona import Persona

# Créer un rôle d'expert technique
tech_expert = Persona(
    name="TechExpert",
    role="Senior Software Engineer",
    goals="Help developers solve complex technical problems with detailed explanations.",
    background="10+ years experience in Python, AI/ML, and distributed systems."
)

# Appliquer le rôle à l'agent
agent.set_persona(tech_expert)
agent.save()

# L'agent répondra désormais en tant qu'expert technique
response = agent.run("How should I design a scalable microservices architecture?")

3. Intégration d'outils

from memorizz.database.mongodb import MongoDBTools, MongoDBToolsConfig

# Configurer la base de données des outils
tools_config = MongoDBToolsConfig(
    uri="your-mongodb-atlas-uri",
    database_name="my_tools_db"
)

# Enregistrer les outils avec un décorateur
with MongoDBTools(tools_config) as tools:
    toolbox = tools.mongodb_toolbox()
    
    @toolbox
    def calculate_compound_interest(principal: float, rate: float, time: int) -> float:
        """Calculate compound interest for financial planning."""
        return principal * (1 + rate) ** time
    
    @toolbox
    def get_weather(city: str) -> str:
        """Get current weather for a city."""
        # Votre code d'intégration d'API météo
        return f"Weather in {city}: 72°F, sunny"

# Ajouter les outils à l'agent
agent.add_tool(toolbox=tools)

# L'agent peut maintenant découvrir et utiliser ces outils automatiquement
response = agent.run("What's the weather in San Francisco and calculate interest on $1000 at 5% for 3 years?")

Types de mémoire

MemoRizz prend en charge différentes catégories de mémoire pour organiser les informations :

• Conversation : Historique de chat et contexte de conversation
• Task : Informations orientées objectif et suivi de progression
• Workflow : Informations sur les processus en plusieurs étapes
• General : Connaissances factuelles et informations déclaratives
• Working : Espace de traitement temporaire (contexte LLM)

Fonctionnalités avancées

Stockage et récupération de la mémoire

# Stocker des informations avec intégration automatique
agent.store_memory("I prefer Python for backend development", memory_type="general")

# Plus tard, des requêtes sémantiquement pertinentes récupéreront ces informations
response = agent.run("What programming languages do I like?")
# L'agent trouvera et utilisera la préférence stockée

Contrôle de la mémoire avec métadonnées

# Stocker des informations avec des métadonnées
agent.store_memory(
    content="Completed project X with React and Node.js",
    memory_type="task",
    metadata={"project": "X", "technologies": ["React", "Node.js"]}
)

# Récupérer une mémoire spécifique
memories = agent.retrieve_memories(
    query="projects with React",
    memory_type="task",
    limit=5
)

Configuration de l'environnement

# Obligatoire
export OPENAI_API_KEY="your-openai-api-key"
export MONGODB_URI="your-mongodb-atlas-uri"

# Facultatif
export MONGODB_DB_NAME="memorizz"  # Nom de base de données par défaut

Étapes de configuration

1. Créer un cluster MongoDB Atlas
2. Activer la recherche vectorielle sur le cluster
3. Créer une base de données et des collections pour votre agent
4. Obtenir la chaîne de connexion

Questions fréquentes

• Connexion MongoDB : Assurez-vous que votre IP est sur liste blanche dans Atlas
• Recherche vectorielle : Vérifiez que la recherche vectorielle est activée sur le cluster
• Clé API : Vérifiez que la clé API OpenAI est valide et dispose de crédits

Exemples de projets

Consultez les exemples fonctionnels complets dans le répertoire examples/ :

• Agent de base : Agent conversationnel simple avec mémoire
• Agent spécialisé : Expert technique avec un rôle
• Intégration d'outils : Agent avec appel de fonctions personnalisées
• Gestion de la mémoire : Stockage et récupération avancés de la mémoire

Valeur d'apprentissage technique

Cette bibliothèque démontre les concepts clés suivants :

• Architecture des agents d'IA : Mémoire, raisonnement et utilisation d'outils
• Bases de données vectorielles : Recherche sémantique et récupération
• Intégration LLM : Appel de fonctions et gestion du contexte
• Conception logicielle : Abstractions claires et architecture évolutive