Si has estado explorando el mundo de la IA y los datos, sabes lo poderoso que puede ser conectar los puntos entre diferentes piezas de información. Neo4j, una popular base de datos de gráficos, facilita la visualización y gestión de estas conexiones. Pero, ¿y si pudieras hacer preguntas en inglés sencillo y obtener respuestas directamente de tus datos? Ahí es donde entra OpenAI. En este artículo, te mostraré cómo configurar un sencillo chatbot de Knowledge Graph utilizando Neo4j AuraDB y los modelos de lenguaje de OpenAI. Ya sea que estés comenzando o buscando expandir tus conocimientos, este tutorial te guiará a través de todo lo que necesitas saber.
Tabla de contenidos
Cómo crear una instancia con Neo4j
Accede a la consola de Neo4j. Luego puedes registrarte o iniciar sesión. Ahora estás dentro de la consola. Una vez dentro, sigue estos pasos:
1. Crea una nueva instancia haciendo clic en «nueva instancia»
2. Elige el plan que quieras. Te sugiero que empieces por el gratuito.
3. Ahora ya está. Recoge el URI de conexión y listo.
Conéctalo a tu instancia
Necesitas cuatro cosas:
- Clave API de OpenAI
- URI de Neo4j
- Nombre de usuario de Neo4j
- Contraseña Neo4j
Ahora que tienes todo lo que necesitas, vamos a conectarnos a la base de datos de Aura.
Primero, configúralos como variables de entorno.
from langchain_community.graphs import Neo4jGraph
# Set up environment variables
os.environ["OPENAI_API_KEY"] = "sk-***"
os.environ["NEO4J_URI"] = "neo4j+s://***"
os.environ["NEO4J_USERNAME"] = "***"
os.environ["NEO4J_PASSWORD"] = "***"
self.graph = Neo4jGraph()
El constructor Neo4jGraph() se instanciará automáticamente utilizando las variables de entorno.
Knowledge Graph Class
import os
from langchain_experimental.graph_transformers import LLMGraphTransformer
from langchain_openai import ChatOpenAI
from langchain_community.graphs import Neo4jGraph
from langchain.chains import GraphCypherQAChain
from langchain_core.documents import Document
from langchain.prompts import PromptTemplate
class KnowledgeGraph:
def __init__(self):
self.llm = ChatOpenAI(temperature=0, model_name="gpt-4o-mini")
self.graph = Neo4jGraph()
self.llm_transformer = LLMGraphTransformer(
llm=self.llm
)
self.qa_prompt = PromptTemplate(
input_variables=["question", "context"],
template="""
You are an AI assistant helping to answer questions about...
Question: {question}
Context: {context}
Answer:
"""
)
self.cypher_prompt = PromptTemplate(
input_variables=["question"],
template="""
You are an AI assistant designed to translate natural language questions into Cypher queries for a Neo4j graph database about triage systems. The graph has the following structure:
Nodes:
- Node A
- Node B
- Node C
Relationships:
- Relationship A
- Relationship B
- Relationship C
- Relationship D
Given a question, create a Cypher query that will retrieve the relevant information from the graph. Focus on using appropriate node labels, relationship types, and properties. Use MATCH, WHERE, and RETURN clauses as needed. If you need to perform any string matching, use case-insensitive comparison with '=~' and '(?i)'.
Question: {question}
Cypher query:
"""
)
self.qa_chain = GraphCypherQAChain.from_llm(
self.llm,
graph=self.graph,
verbose=True,
validate_cypher=True,
qa_prompt=self.qa_prompt,
cypher_prompt=self.cypher_prompt
)
Para la clase knowledge graph, iniciaremos el LLM, el Graph y el LLMGraphTransformer. También configuraremos nuestro QA Prompt y el Cypher Prompt. El QA Prompt es un prompt estándar que hará que el LLM responda a tus preguntas como tú quieras. Puedes darle a tu IA un personaje junto con varias instrucciones sobre cómo debe operar. El Cypher Prompt es otra parte de la ecuación. La cadena QA tiene que generar una consulta Cypher basada en tu consulta de entrada, por lo que el Cypher Prompt se utilizará para ayudar al LLM a crear esa consulta. Por lo tanto, necesitas proporcionar detalles sobre tus nodos y relaciones, así como cualquier otra cosa que pueda mejorar la generación de la consulta Cypher. Ambos prompts son extremadamente importantes. Al final, solo tienes que instanciar tu cadena QA y estarás listo.
def generate_knowledge_graph(self, text):
documents = [Document(page_content=text)]
graph_documents = self.llm_transformer.convert_to_graph_documents(documents)
self.graph.add_graph_documents(graph_documents)
print("Knowledge graph generated and stored in Neo4j.")
print(f"Nodes: {graph_documents[0].nodes}")
print(f"Relationships: {graph_documents[0].relationships}")
Esta es una función simple que generará tu gráfico de conocimiento. Primero, necesitas una lista de Documentos. Luego, puedes usar el asombroso LLMGraphTransformer para convertir tus documentos en nodos y relaciones. Una vez que tenemos nuestros documentos del grafo, sólo tenemos que utilizar la función add_graph_documents() para añadir nuestros nuevos componentes al grafo.
def query_knowledge_graph(self, query):
response = self.qa_chain.invoke({"query": query})
return response["result"]
En esta función, simplemente estamos invocando nuestro qa_chain con una consulta y devolviendo la respuesta.
def refresh_schema(self):
self.graph.refresh_schema()
print("Graph schema refreshed.")
print(self.graph.schema)
La función refresh_schema() es importante porque cada vez que añadas nuevos documentos al grafo, la estructura cambiará. Esto asegurará que su conocimiento está utilizando la versión actualizada en lugar de la anterior.
Terminal-Based Interface
from knowledge_graph import KnowledgeGraph
def main():
app = KnowledgeGraph()
while True:
print("\n1. Generate Knowledge Graph")
print("2. Query Knowledge Graph")
print("3. Refresh Schema")
print("4. Exit")
choice = input("Enter your choice (1-4): ")
if choice == "1":
text = input("Enter the text to generate a knowledge graph: ")
app.generate_knowledge_graph(text)
elif choice == "2":
query = input("Enter your query: ")
result = app.query_knowledge_graph(query)
print("Answer:", result)
elif choice == "3":
app.refresh_schema()
elif choice == "4":
break
else:
print("Invalid choice. Please try again.")
if __name__ == "__main__":
main()
En la interfaz, tenemos una interfaz estándar basada en opciones. Ofrecemos cuatro opciones: generar un gráfico, consultar el gráfico, actualizar el gráfico y salir. Cada opción activa una función específica, por lo que es muy fácil de manejar.
El futuro de la IA está en hacer que las herramientas potentes sean accesibles e intuitivas, y lo que hemos construido aquí es un atisbo de ese futuro. A medida que sigamos explorando, encontraremos nuevas formas de aprovechar esta tecnología, ya sea para automatizar tareas, mejorar el análisis de datos o desarrollar aplicaciones más interactivas y receptivas. El viaje a partir de aquí está lleno de oportunidades apasionantes. Estamos impacientes por ver qué más nos depara el mundo.