neo4j graphrag python
Neo4j GraphRAG Package for Python 1.2.1
O pacote oficial Neo4j GraphRAG para Python permite que os desenvolvedores criem aplicativos de geração aumentada de recuperação de gráficos (GraphRAG) usando o poder do Neo4j e Python. Como uma biblioteca própria, ela oferece uma solução robusta, rica em recursos e de alto desempenho, com a garantia adicional de suporte e manutenção de longo prazo diretamente do Neo4j.
A documentação pode ser encontrada aqui
| Versão | Suportado? |
|---|---|
| 3.12 | ✓ |
| 3.11 | ✓ |
| 3.10 | ✓ |
| 3.9 | ✓ |
| 3.8 | ✗ |
Para instalar a versão estável mais recente, execute:
pip install neo4j-graphrag pygraphviz é usado para visualizar pipelines. As instruções de instalação podem ser encontradas aqui.
Os scripts abaixo demonstram como começar a usar o pacote e usar seus principais recursos. Para executar esses exemplos, certifique-se de ter uma instância Neo4j instalada e em execução e atualize as variáveis NEO4J_URI , NEO4J_USERNAME e NEO4J_PASSWORD em cada script com os detalhes de sua instância Neo4j. Para os exemplos, certifique-se de exportar sua chave OpenAI como uma variável de ambiente chamada OPENAI_API_KEY . Exemplos adicionais estão disponíveis na pasta de examples .
NOTA: A biblioteca principal APOC deve estar instalada em sua instância Neo4j para usar este recurso
Este pacote oferece dois métodos para construir um gráfico de conhecimento.
A classe Pipeline oferece amplas opções de personalização, tornando-a ideal para casos de uso avançados. Veja a pasta examples/pipeline para exemplos de como usar esta classe.
Para uma abordagem mais simplificada, a classe SimpleKGPipeline oferece uma camada de abstração simplificada sobre o Pipeline , facilitando a construção de gráficos de conhecimento. Ambas as classes suportam trabalhar diretamente com texto e PDFs.
import asyncio
from neo4j import GraphDatabase
from neo4j_graphrag . embeddings import OpenAIEmbeddings
from neo4j_graphrag . experimental . pipeline . kg_builder import SimpleKGPipeline
from neo4j_graphrag . llm . openai_llm import OpenAILLM
NEO4J_URI = "neo4j://localhost:7687"
NEO4J_USERNAME = "neo4j"
NEO4J_PASSWORD = "password"
# Connect to the Neo4j database
driver = GraphDatabase . driver ( NEO4J_URI , auth = ( NEO4J_USERNAME , NEO4J_PASSWORD ))
# List the entities and relations the LLM should look for in the text
entities = [ "Person" , "House" , "Planet" ]
relations = [ "PARENT_OF" , "HEIR_OF" , "RULES" ]
potential_schema = [
( "Person" , "PARENT_OF" , "Person" ),
( "Person" , "HEIR_OF" , "House" ),
( "House" , "RULES" , "Planet" ),
]
# Create an Embedder object
embedder = OpenAIEmbeddings ( model = "text-embedding-3-large" )
# Instantiate the LLM
llm = OpenAILLM (
model_name = "gpt-4o" ,
model_params = {
"max_tokens" : 2000 ,
"response_format" : { "type" : "json_object" },
"temperature" : 0 ,
},
)
# Instantiate the SimpleKGPipeline
kg_builder = SimpleKGPipeline (
llm = llm ,
driver = driver ,
embedder = embedder ,
entities = entities ,
relations = relations ,
on_error = "IGNORE" ,
from_pdf = False ,
)
# Run the pipeline on a piece of text
text = (
"The son of Duke Leto Atreides and the Lady Jessica, Paul is the heir of House "
"Atreides, an aristocratic family that rules the planet Caladan."
)
asyncio . run ( kg_builder . run_async ( text = text ))
driver . close ()Exemplo de gráfico de conhecimento criado usando o script acima:
Ao criar um índice vetorial, certifique-se de combinar o número de dimensões no índice com o número de dimensões que seus embeddings possuem.
from neo4j import GraphDatabase
from neo4j_graphrag . indexes import create_vector_index
NEO4J_URI = "neo4j://localhost:7687"
NEO4J_USERNAME = "neo4j"
NEO4J_PASSWORD = "password"
INDEX_NAME = "vector-index-name"
# Connect to the Neo4j database
driver = GraphDatabase . driver ( NEO4J_URI , auth = ( NEO4J_USERNAME , NEO4J_PASSWORD ))
# Create the index
create_vector_index (
driver ,
INDEX_NAME ,
label = "Chunk" ,
embedding_property = "embedding" ,
dimensions = 3072 ,
similarity_fn = "euclidean" ,
)
driver . close ()Este exemplo demonstra um método para fazer upserting de dados em seu banco de dados Neo4j. É importante observar que existem abordagens alternativas, como usar o driver Neo4j Python.
Certifique-se de que seu índice vetorial seja criado antes de executar este exemplo.
from neo4j import GraphDatabase
from neo4j_graphrag . embeddings import OpenAIEmbeddings
from neo4j_graphrag . indexes import upsert_vector
NEO4J_URI = "neo4j://localhost:7687"
NEO4J_USERNAME = "neo4j"
NEO4J_PASSWORD = "password"
# Connect to the Neo4j database
driver = GraphDatabase . driver ( NEO4J_URI , auth = ( NEO4J_USERNAME , NEO4J_PASSWORD ))
# Create an Embedder object
embedder = OpenAIEmbeddings ( model = "text-embedding-3-large" )
# Generate an embedding for some text
text = (
"The son of Duke Leto Atreides and the Lady Jessica, Paul is the heir of House "
"Atreides, an aristocratic family that rules the planet Caladan."
)
vector = embedder . embed_query ( text )
# Upsert the vector
upsert_vector (
driver ,
node_id = 0 ,
embedding_property = "embedding" ,
vector = vector ,
)
driver . close ()Observe que, ao consultar um índice vetorial Neo4j, é usada a pesquisa aproximada do vizinho mais próximo, o que nem sempre fornece resultados exatos. Para obter mais informações, consulte a documentação do Neo4j sobre limitações e problemas de índices vetoriais.
No exemplo abaixo, realizamos uma pesquisa vetorial simples usando um recuperador que realiza uma pesquisa por similaridade no índice vector-index-name de vetor.
Esta biblioteca fornece mais recuperadores além do VectorRetriever . Consulte a pasta de examples para obter exemplos de como usar esses recuperadores.
Antes de executar este exemplo, certifique-se de que seu índice vetorial foi criado e preenchido.
from neo4j import GraphDatabase
from neo4j_graphrag . embeddings import OpenAIEmbeddings
from neo4j_graphrag . generation import GraphRAG
from neo4j_graphrag . llm import OpenAILLM
from neo4j_graphrag . retrievers import VectorRetriever
NEO4J_URI = "neo4j://localhost:7687"
NEO4J_USERNAME = "neo4j"
NEO4J_PASSWORD = "password"
INDEX_NAME = "vector-index-name"
# Connect to the Neo4j database
driver = GraphDatabase . driver ( NEO4J_URI , auth = ( NEO4J_USERNAME , NEO4J_PASSWORD ))
# Create an Embedder object
embedder = OpenAIEmbeddings ( model = "text-embedding-3-large" )
# Initialize the retriever
retriever = VectorRetriever ( driver , INDEX_NAME , embedder )
# Instantiate the LLM
llm = OpenAILLM ( model_name = "gpt-4o" , model_params = { "temperature" : 0 })
# Instantiate the RAG pipeline
rag = GraphRAG ( retriever = retriever , llm = llm )
# Query the graph
query_text = "Who is Paul Atreides?"
response = rag . search ( query_text = query_text , retriever_config = { "top_k" : 5 })
print ( response . answer )
driver . close ()Você deve assinar o contrato de licença de contribuidores para poder fazer contribuições para este projeto.
Nossas dependências Python são gerenciadas usando Poetry. Se o Poetry ainda não estiver instalado em seu sistema, você pode seguir as instruções aqui para configurá-lo. Para iniciar o desenvolvimento deste projeto, comece clonando o repositório e depois instale todas as dependências necessárias, incluindo as dependências de desenvolvimento, com o seguinte comando:
poetry install --with devSe você tiver um bug para relatar ou um recurso para solicitar, primeiro pesquise para ver se já existe um problema. Se não existir um problema relacionado, levante um novo problema usando o formulário de problemas.
Se você for um cliente Neo4j Enterprise, também poderá entrar em contato com o Suporte ao Cliente.
Se você não tem um bug para relatar ou solicitar um recurso, mas precisa de ajuda com a biblioteca; o suporte da comunidade está disponível através da comunidade online Neo4j e/ou Discord.
main e comece com suas alterações!Nossa base de código segue padrões rígidos de formatação e linting usando Ruff para verificações de qualidade de código e Mypy para verificação de tipo. Antes de contribuir, certifique-se de que todo o código esteja formatado corretamente, livre de problemas de linting e inclua anotações de tipo precisas.
A adesão a esses padrões é necessária para que as contribuições sejam aceitas.
Recomendamos configurar o pré-comprometimento para automatizar as verificações de qualidade do código. Isso garante que suas alterações atendam às nossas diretrizes antes de serem confirmadas.
Instale o pré-commit seguindo o guia de instalação.
Configure os ganchos de pré-confirmação executando:
pre-commit installPara verificar manualmente se um arquivo atende aos requisitos de qualidade, execute:
pre-commit run --file path/to/fileQuando terminar as alterações, crie uma solicitação pull (PR) usando o fluxo de trabalho a seguir.
main .CHANGELOG.md se você tiver feito alterações significativas no projeto, incluindo:CHANGELOG.md breves e concentre-se nas alterações mais importantes.CHANGELOG.md @CodiumAI-Agent /update_changelog
CHANGELOG.md em ‘Próximo’.Instale as dependências do projeto e execute o seguinte comando para executar os testes de unidade localmente:
poetry run pytest tests/unitPara executar testes ponta a ponta (e2e), você precisa que os seguintes serviços sejam executados localmente:
A maneira mais simples de configurá-los é usando Docker Compose:
docker compose -f tests/e2e/docker-compose.yml up (dica: se você encontrar algum problema de cache nos bancos de dados, poderá removê-lo completamente executando docker compose -f tests/e2e/docker-compose.yml down )
Assim que todos os serviços estiverem em execução, execute o seguinte comando para executar os testes e2e:
poetry run pytest tests/e2e
