personal graph

Graph personal: Gráfico para la memoria de construcción para aplicaciones de IA

Personal-Graph es una biblioteca de Python para crear, administrar y consultar gráficos de conocimiento. Su objetivo es ayudar a resolver los desafíos de memoria de trabajo y a largo plazo en los sistemas de IA, particularmente modelos de idiomas grandes (LLM).

Características

• Puede ser rápido : construido sobre libsql, un motor sqlite de alto rendimiento en óxido
• ? Un DB por usuario : Integre con TURSO DB para gráficos privados de conocimiento específicos del usuario
• Interfaces del lenguaje natural : consultas del lenguaje natural impulsadas por SQLite-VSS e instructor
• ? Listo de ML : Exportar datos para bibliotecas de aprendizaje automático como NetworkX y PYG
• ✅ Admite la ejecución local con Ollama LLMS y los modelos de incrustación
• ✅ Admite DB local para almacenar gráfico e incrustaciones

Ceñudo

• Agregar soporte para la base de datos columnar: DuckDB
• Implementación de algoritmos de red neuronal gráfica: Transe, Transe, Query2Box

Instalación

Instale el gráfico personal con PIP:

pip install personal-graph

Uso

Construir un recuerdo de trabajo para una 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." )

En este ejemplo, insertamos información sobre Alice y Bob en el gráfico de conocimiento. Luego usamos el método de búsqueda para recuperar información relevante basada en las consultas dadas. La información recuperada se puede utilizar como parte de la memoria de trabajo de la IA para responder preguntas y proporcionar contexto para nuevas interacciones.

Construyendo memoria a largo plazo

 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 )

En este ejemplo, almacenamos información sobre conversaciones con el usuario, incluida la fecha, el tema y un puntaje de profundidad. El puntaje de profundidad representa cuán significativa fue la conversación.

Cuando el usuario pregunta sobre la conversación más profunda, buscamos la conversación con la puntuación de profundidad más alta utilizando el método de búsqueda. Ordenamos los resultados por la puntuación de profundidad en orden descendente y limitamos la salida a una conversación.

Si se encuentra una conversación, la IA responde con la fecha y el tema de la conversación más profunda. Si no se encuentran conversaciones, la IA informa al usuario que no tiene suficiente información.

Este ejemplo demuestra cómo se puede utilizar el gráfico personal para construir memoria a largo plazo sobre las interacciones del usuario y recuperar información específica basada en criterios como la profundidad de la conversación.

Creación y consulta de un gráfico de conocimiento

 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 )

Recuperación y respuesta de pregunta

 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 )

Uso local

 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 a Pyg, luego de regreso a PersonalGraph

El siguiente es solo un boceto del flujo planificado. 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 )

Descripción del video

Este video describe mejor la biblioteca de gráficos personales. [! Gráfico personal]

Para obtener más detalles y documentación de API, consulte la documentación del gráfico personal.

Que contribuye

¡Las contribuciones son bienvenidas! No dude en crear problemas para errores y solicitudes de funciones.

Licencia

El gráfico personal se libera bajo la licencia MIT.

Contacto

Preguntas, comentarios o sugerencias? Comuníquese en [email protected] o abra un problema en Github.