Memoripy: An AI Memory Layer for Context-Aware Applications

Introdução

Memoripy é uma poderosa biblioteca Python que fornece uma camada avançada de memória de IA para aplicações que exigem gerenciamento de contexto sofisticado. Ela aborda o desafio de manter o estado conversacional e informações relevantes ao longo do tempo, oferecendo armazenamento de memória de curto e longo prazo. Projetada para aplicações orientadas por IA, Memoripy suporta integração perfeita com APIs populares de LLM, como OpenAI, Azure OpenAI, OpenRouter e Ollama, permitindo um gerenciamento inteligente de memória através de recursos como recuperação contextual, decaimento de memória e agrupamento hierárquico.

Instalação

Para começar com Memoripy, você pode instalá-lo facilmente usando pip:

pip install memoripy

Exemplos

O exemplo a seguir demonstra como inicializar MemoryManager, armazenar interações, recuperar memórias relevantes e gerar respostas usando Memoripy. Este script mostra a funcionalidade principal para construir aplicações de IA sensíveis ao contexto.

from memoripy import MemoryManager, JSONStorage
from memoripy.implemented_models import OpenAIChatModel, OllamaEmbeddingModel

def main():
    # Replace 'your-api-key' with your actual OpenAI API key
    api_key = "your-key"
    if not api_key:
        raise ValueError("Please set your OpenAI API key.")

    # Define chat and embedding models
    chat_model_name = "gpt-4o-mini"  # Specific chat model name
    embedding_model_name = "mxbai-embed-large"  # Specific embedding model name

    # Choose your storage option
    storage_option = JSONStorage("interaction_history.json")
    # Or use in-memory storage:
    # from memoripy import InMemoryStorage
    # storage_option = InMemoryStorage()

    # Initialize the MemoryManager with the selected models and storage
    memory_manager = MemoryManager(
        OpenAIChatModel(api_key, chat_model_name),
        OllamaEmbeddingModel(embedding_model_name),
        storage=storage_option
    )

    # New user prompt
    new_prompt = "My name is Khazar"

    # Load the last 5 interactions from history (for context)
    short_term, _ = memory_manager.load_history()
    last_interactions = short_term[-5:] if len(short_term) >= 5 else short_term

    # Retrieve relevant past interactions, excluding the last 5
    relevant_interactions = memory_manager.retrieve_relevant_interactions(new_prompt, exclude_last_n=5)

    # Generate a response using the last interactions and retrieved interactions
    response = memory_manager.generate_response(new_prompt, last_interactions, relevant_interactions)

    # Display the response
    print(f"Generated response:\n{response}")

    # Extract concepts for the new interaction
    combined_text = f"{new_prompt} {response}"
    concepts = memory_manager.extract_concepts(combined_text)

    # Store this new interaction along with its embedding and concepts
    new_embedding = memory_manager.get_embedding(combined_text)
    memory_manager.add_interaction(new_prompt, response, new_embedding, concepts)

if __name__ == "__main__":
    main()

Este exemplo demonstra o ciclo de vida completo de uma interação, desde a inicialização e processamento do prompt até a geração da resposta e o armazenamento da memória.

Porquê usar Memoripy?

Memoripy oferece várias razões convincentes para desenvolvedores que constroem aplicações de IA:

Gerenciamento de Memória Sofisticado: Ele distingue inteligentemente entre memória de curto e longo prazo, garantindo que o contexto seja sempre relevante e atualizado.
Recuperação Contextual: Aproveitando embeddings, conceitos e associações baseadas em grafos, Memoripy recupera interações passadas altamente relevantes, melhorando significativamente a qualidade das respostas da IA.
Memória Dinâmica: Recursos como decaimento e reforço da memória garantem que memórias mais antigas e menos relevantes desapareçam, enquanto memórias frequentemente acessadas e importantes são fortalecidas, imitando processos de memória naturais.
Organização Semântica: O agrupamento hierárquico agrupa memórias semelhantes em grupos semânticos, tornando a recuperação mais eficiente e semanticamente coerente.
Integração Flexível: Com suporte para múltiplas APIs de LLM e embeddings, Memoripy é adaptável a vários ecossistemas de IA e escolhas de modelos.