Conheça Memoripy: uma biblioteca Python que traz recursos de memória em tempo real para aplicativos de IA

Os sistemas de inteligência artificial muitas vezes lutam para manter um contexto significativo durante interações prolongadas. Esta limitação representa desafios para aplicações como chatbots e assistentes virtuais, onde manter uma conversa coesa é fundamental. Muitos modelos tradicionais de IA operam de forma aleatória, concentrando-se apenas em entradas imediatas, sem considerar o progresso de transações anteriores. Esta falta de memória eficiente leva a interações fragmentadas e inconsistentes, dificultando a capacidade de construir sistemas de IA verdadeiramente envolventes e sensíveis ao contexto.

Conheça Memoripy: uma biblioteca Python que traz o poder da memória real para aplicativos de IA. Memoripy aborda o problema de reter o contexto de uma conversa equipando os sistemas de IA com memória estruturada, permitindo-lhes armazenar, recuperar e desenvolver com eficácia interações anteriores. Memoripy fornece armazenamento de memória de curto e longo prazo, permitindo que os sistemas de IA retenham o contexto de interações recentes, ao mesmo tempo que retêm informações importantes a longo prazo. Ao organizar a memória de uma forma que imita a cognição humana – priorizando eventos recentes e retendo informações importantes – o Memoripy garante que as interações permaneçam relevantes e relevantes ao longo do tempo.

Memoripy organiza a memória em clusters de curto e longo prazo, permitindo priorizar interações recentes para recuperação imediata, ao mesmo tempo que retém interações históricas importantes para uso futuro. Isto evita que a IA seja sobrecarregada por dados excessivos, ao mesmo tempo que garante que as informações relevantes estão acessíveis. Memoripy também usa agrupamento semântico, agrupando memórias semelhantes para facilitar a recuperação de conteúdo relevante. Esta capacidade permite que os sistemas de IA identifiquem e vinculem rapidamente memórias relacionadas, melhorando assim a qualidade da resposta. Além disso, Memoripy combina técnicas de deterioração e reforço de memória, onde memórias menos úteis são gradualmente esgotadas e memórias acessadas com frequência são fortalecidas, refletindo os princípios da memória humana. O design do Memoripy enfatiza o armazenamento local, permitindo que os desenvolvedores gerenciem as operações de memória inteiramente na infraestrutura local. Essa abordagem reduz as preocupações com a privacidade e oferece flexibilidade na integração com modelos de linguagem gerenciados localmente, bem como com serviços externos, como OpenAI e Ollama.

Para mostrar como o Memoripy pode ser integrado a um aplicativo de IA, considere o seguinte exemplo:

from memoripy import MemoryManager, JSONStorage

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 = "openai"  # Choose 'openai' or 'ollama' for chat
    chat_model_name = "gpt-4o-mini"  # Specific chat model name
    embedding_model = "ollama"  # Choose 'openai' or 'ollama' for embeddings
    embedding_model_name = "mxbai-embed-large"  # Specific embedding model name

    # Choose your storage option
    storage_option = JSONStorage("interaction_history.json")

    # Initialize the MemoryManager with the selected models and storage
    memory_manager = MemoryManager(
        api_key=api_key,
        chat_model=chat_model,
        chat_model_name=chat_model_name,
        embedding_model=embedding_model,
        embedding_model_name=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()

Neste roteiro, o MemoryManager Ele é implementado com modelos de diálogo e incorporação especificados, bem como uma opção de armazenamento. A entrada do novo usuário é processada e o sistema recupera interações passadas relevantes para gerar uma resposta contextualmente apropriada. As interações são então salvas com conceitos incorporados e extraídos para uso futuro.

Memoripy oferece um avanço significativo na construção de sistemas de IA sensíveis ao contexto. A capacidade de armazenar e recuperar informações relevantes permite o desenvolvimento de assistentes virtuais, agentes de chat e sistemas de atendimento ao cliente que proporcionam interações consistentes e personalizadas. Por exemplo, um assistente virtual que utiliza o Memoripy pode lembrar as preferências do usuário ou detalhes de solicitações anteriores, fornecendo assim uma resposta mais personalizada. Os testes iniciais mostram que os sistemas de IA, incluindo o Memoripy, apresentam maior satisfação do usuário, gerando respostas mais coerentes e contextualmente apropriadas. Além disso, a ênfase do Memoripy no armazenamento local é importante para aplicações preocupadas com a privacidade, pois permite que os dados sejam gerenciados com segurança sem depender de servidores externos.

Concluindo, Memoripy representa um passo importante em direção a interações complexas de IA, fornecendo recursos de memória reais que melhoram a retenção e relevância do conteúdo. Ao programar a memória de uma forma que imita de perto os processos cognitivos humanos, o Memoripy abre caminho para sistemas de IA que podem se adaptar com base nas interações cumulativas do usuário e fornecer informações personalizadas e conscientes do contexto. Esta biblioteca fornece aos desenvolvedores as ferramentas necessárias para criar IA que não apenas processe entradas, mas também aprenda com as interações de maneira significativa.

Confira Repositório GitHub. Todo o crédito deste estudo vai para os pesquisadores deste projeto. Além disso, não se esqueça de nos seguir Twitter e junte-se ao nosso Estação telefônica de novo LinkedIn Gracima. Se você gosta do nosso trabalho, você vai gostar do nosso jornal.. Não se esqueça de participar do nosso SubReddit de 55k + ML.

[FREE AI WEBINAR] Usando processamento inteligente de documentos e GenAI em serviços financeiros e transações imobiliárias– Da estrutura à produção