personal graph

Graphique personnel: graphique pour la création de mémoire pour les applications d'IA

Personal-Graph est une bibliothèque Python pour créer, gérer et interroger les graphiques de connaissances. Il vise à aider à résoudre les défis de la mémoire à long terme et à long terme dans les systèmes d'IA, en particulier les modèles de langage grand (LLM).

Caractéristiques

• Peut être rapide : construit sur Libsql, un moteur Sqlite haute performance à Rust
• ? Une base de base de données par utilisateur : intégrer à TUSSO DB pour les graphiques de connaissances privés et spécifiques à l'utilisateur
• Interfaces en langage naturel : requêtes en langage naturel alimentées par SQLite-VSS et instructeur
• ? ML-prêt : les données d'exportation pour les bibliothèques d'apprentissage automatique comme NetworkX et PYG
• ✅ prend en charge l'exécution locale avec Olllama LLMS et les modèles d'intégration
• ✅ prend en charge la base de données locale pour le stockage du graphique et des intégres

Vider

• Ajout de la prise en charge de la base de données colonnes: DuckDB
• Implémentation d'algorithmes de réseau neuronal graphique: Transe, Transe, Query2box

Installation

Installez le graphique personnel à l'aide de PIP:

pip install personal-graph

Usage

Construire une mémoire de travail pour une IA

 from personal_graph import GraphDB
from personal_graph . text import text_to_graph
from personal_graph . vector_store import VliteVSS

vector_store = VliteVSS ( collection = "memories" )
graph = GraphDB ( vector_store = vector_store )

# Insert information into the graph
g = text_to_graph ( "Alice is Bob's sister. Bob works at Google." )
graph . insert_graph ( g )

# Retrieve relevant information from the graph
query = "Who is Alice?"
results = graph . search ( query )
print ( results )

# Use the retrieved information to answer questions
print ( f"Question: { query } " )
print ( f"Answer: Alice is Bob's sister." )

query = "Where does Bob work?"
results = graph . search ( query )
print ( results )
print ( f"Question: { query } " )
print ( f"Answer: Bob works at Google." )

Dans cet exemple, nous insérons des informations sur Alice et Bob dans le graphique de connaissances. Nous utilisons ensuite la méthode de recherche pour récupérer des informations pertinentes en fonction des requêtes données. Les informations récupérées peuvent être utilisées dans le cadre de la mémoire de travail de l'IA pour répondre aux questions et fournir un contexte pour d'autres interactions.

Construire une mémoire à long terme

 from personal_graph import GraphDB
from personal_graph . vector_store import VliteVSS

vector_store = VliteVSS ( collection = "memories" )
graph = GraphDB ( vector_store = vector_store )

# Insert information about conversations with the user over time
graph . insert (
  text = "User talked about their childhood dreams and aspirations." ,
  attributes = {
    "date" : "2023-01-15" ,
    "topic" : "childhood dreams" ,
    "depth_score" : 3
  })

graph . insert (
  text = "User discussed their fears and insecurities in their current relationship." ,
  attributes = {
    "date" : "2023-02-28" ,
    "topic" : "relationship fears" ,
    "depth_score" : 4
})

graph . insert (
  text = "User shared their spiritual beliefs and existential questions." ,
  attributes = {
    "date" : "2023-03-10" ,
    "topic" : "spirituality and existence" ,
    "depth_score" : 5
})

graph . insert (
  text = "User mentioned their favorite hobbies and weekend activities." ,
  attributes = {
    "date" : "2023-04-02" ,
    "topic" : "hobbies" ,
    "depth_score" : 2
})

# User queries about the deepest conversation
query = "What was the deepest conversation we've ever had?"

deepest_conversation = graph . search ( query , sort_by = "depth_score" , descending = True , limit = 1 )

Dans cet exemple, nous stockons des informations sur les conversations avec l'utilisateur, y compris la date, le sujet et un score de profondeur. Le score de profondeur représente la signification de la conversation.

Lorsque l'utilisateur pose des questions sur la conversation la plus profonde, nous recherchons la conversation avec le score de profondeur le plus élevé en utilisant la méthode de recherche. Nous trierons les résultats par le score de profondeur dans l'ordre descendant et limitons la sortie à une conversation.

Si une conversation est trouvée, l'IA répond avec la date et le sujet de la conversation la plus profonde. Si aucune conversation n'est trouvée, l'IA informe l'utilisateur qu'elle n'a pas suffisamment d'informations.

Cet exemple montre comment le graphique personnel peut être utilisé pour créer une mémoire à long terme sur les interactions utilisateur et récupérer des informations spécifiques en fonction de critères comme la profondeur de conversation.

Créer et interroger un graphique de connaissances

 from personal_graph import GraphDB
from personal_graph . text import text_to_graph
from personal_graph . vector_store import VliteVSS

vector_store = VliteVSS ( collection = "memories" )

graphdb = GraphDB ( vector_store = vector_store )

nl_query = "Increased thirst, weight loss, increased hunger, and frequent urination are all symptoms of diabetes."
kg = text_to_graph ( text = nl_query )
graphdb . insert_graph ( kg )

search_query = "I am losing weight too frequently."
g = text_to_graph ( search_query )
print ( g )

graphdb . insert_graph ( g )

Récupération et réponses aux questions

 import os
import dspy
from personal_graph import GraphDB , PersonalRM

db = GraphDB () # storage_db is in-memory sqlite, vector_db is in vlite
turbo = dspy . OpenAI ( api_key = os . getenv ( "OPENAI_API_KEY" ))
retriever = PersonalRM ( graph = db , k = 2 )
dspy . settings . configure ( lm = turbo , rm = retriever )


class GenerateAnswer ( dspy . Signature ):
    """Answer questions with short factoid answers."""

    context = dspy . InputField ( desc = "may contain relevant facts from user's graph" )
    question = dspy . InputField ()
    answer = dspy . OutputField (
        desc = "a short answer to the question, deduced from the information found in the user's graph"
    )

class RAG ( dspy . Module ):
    def __init__ ( self , depth = 3 ):
        super (). __init__ ()
        self . retrieve = dspy . Retrieve ( k = depth )
        self . generate_answer = dspy . ChainOfThought ( GenerateAnswer )

    def forward ( self , question ):
        context = self . retrieve ( question ). passages
        prediction = self . generate_answer ( context = context , question = question )
        return dspy . Prediction ( context = context , answer = prediction . answer )

rag = RAG ( depth = 2 )
response = rag ( "How is Jack related to James?" )
print ( response . answer )

Utilisation locale

 from personal_graph . graph import GraphDB
from personal_graph . graph_generator import OllamaTextToGraphParser
from personal_graph . database import SQLite
from personal_graph . vector_store import VliteVSS
from personal_graph . clients import OllamaClient , OllamaEmbeddingClient

phi3 = OllamaClient ( model_name = "phi3" )
nomic_embed = OllamaEmbeddingClient ( model_name = "nomic-embed-text" )

storage_db = SQLite ( local_path = "./local.db" )
vector_store = VliteVSS ( collection = "./vectors" )

graph_generator = OllamaTextToGraphParser ( llm_client = phi3 )
print ( graph_generator ) # Should print the InstructorGraphGenerator 

with GraphDB (
    database = storage_db , 
    vector_store = vector_store , 
    graph_generator = graph_generator
  ) as db :
    print ( db )

Personalgraph à PYG, puis retour à PersonalGraph

Ce qui suit n'est qu'un croquis du flux prévu. WIP.

 graphdb = GraphDB ( storage = db , vector_store = vector_store , graph_generator = graph_generator )

graphdb . load_dataset ( "KarateClub" )

pyg_graph = graphdb . to_pyg ()

updated_graph = model ( pyg_graph ) # Run Neural Network algorithms here using PyG

graphdb . from_pyg ( updated_graph )

Description de la vidéo

Cette vidéo décrit le mieux la bibliothèque de graphiques personnels. [! Graphique personnel]

Pour plus de détails et la documentation de l'API, consultez la documentation du graphique personnel.

Contributif

Les contributions sont les bienvenues! N'hésitez pas à créer des problèmes pour les bogues et les demandes de fonctionnalités.

Licence

Le graphique personnel est libéré sous la licence du MIT.

Contact

Questions, commentaires ou suggestions? Contactez la main à [email protected] ou ouvrez un problème sur Github.