Neo4j graph vector database

NEO4J_URI=bolt://localhost:7687  # Neo4j's binary protocol
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=password
NEO4J_DATABASE=neo4j  # Optional: specify database name

neo4j([
  {
    indexId: 'my-vector-index',
    embedder: googleAI.embedder('gemini-embedding-001'),
    clientParams: {
      url: 'bolt://localhost:7687',
      username: 'neo4j',
      password: 'password',
      database: 'neo4j', // Optional
    },
  },
]),

import { Document } from 'genkit';

export async function indexCompanyDocuments(ai: any) {
  // Use the indexer reference
  const INDEXER_REF = neo4jIndexerRef({
    indexId: 'my-vector-index',
    displayName: 'Company Documents Indexer'
  });

  const doc1 = new Document({
    content: [{ text: 'Neo4j integrates natively with Genkit.' }],
    metadata: { category: 'technology', uniqueId: 'doc-101' },
  });

  const doc2 = new Document({
    content: [{ text: 'Vector search allows semantic similarity matching.' }],
    metadata: { category: 'technology', uniqueId: 'doc-102' },
  });

  // Execute the indexing process
  await ai.index({
    indexer: INDEXER_REF,
    documents: [doc1, doc2]
  });

  console.log('Documents indexed successfully.');
}

export async function searchCompanyDocuments(ai: any, userQuery: string) {
  // Use the retriever reference
  const RETRIEVER_REF = neo4jRetrieverRef({
    indexId: 'my-vector-index',
    displayName: 'Company Documents Retriever'
  });

  const docs = await ai.retrieve({
    retriever: RETRIEVER_REF,
    query: userQuery,
    // Optional: limit number of results
    options: { k: 5 },
  });

  return docs;
}

// 1. Initialization with custom mappings
const ai = genkit({
  plugins: [
    googleAI(),
    neo4j([
      {
        indexId: 'custom-entities-idx',
        embedder: googleAI.embedder('gemini-embedding-001'),
        clientParams,

        // Define your domain-specific schema mapping here:
        label: 'Article',
        textProperty: 'bodyContent',
        embeddingProperty: 'semanticVector',
        idProperty: 'articleId',
      },
    ]),
  ],
});

// 2. Retrieval over custom schema
export async function retrieveArticles(query: string) {
  const RETRIEVER_REF = neo4jRetrieverRef({ indexId: 'custom-entities-idx' });

  const docs = await ai.retrieve({
    retriever: RETRIEVER_REF,
    query: query,
    options: { k: 10 },
  });

  return docs;
}

import { MatchSearchClauseStrategy } from 'genkitx-neo4j';

// 1. Initialization with Metadata Filter Optimization
neo4j([
  {
    indexId: 'optimized-docs',
    embedder: googleAI.embedder('gemini-embedding-001'),
    searchStrategy: new MatchSearchClauseStrategy(),
    // Configure the index to optimize filtering on these specific metadata properties
    filterMetadata: ['department', 'status'],
  },
])

// 2. Retrieval with Exact Metadata Matching
export async function retrieveActiveItDocs(ai: any, query: string) {
  const RETRIEVER_REF = neo4jRetrieverRef({ indexId: 'optimized-docs' });

  const docs = await ai.retrieve({
    retriever: RETRIEVER_REF,
    query: query,
    options: {
      k: 10,
      // This filter is applied natively inside the vector index lookup
      filter: { department: 'IT', status: 'active' }
    },
  });

  return docs;
}

// 1. Initialization with Hybrid Search enabled
neo4j([
  {
    indexId: 'hybrid-search-idx',
    embedder: googleAI.embedder('gemini-embedding-001'),
    searchType: 'hybrid', // Enables both vector and full-text keyword retrieval
    fullTextIndexName: 'custom-fulltext-index', // Optional
    fullTextQuery: 'documentation', // Baseline query
  },
])

// 2. Retrieval using Hybrid Search
export async function retrieveWithHybridSearch(ai: any, query: string) {
  const RETRIEVER_REF = neo4jRetrieverRef({ indexId: 'hybrid-search-idx' });

  const docs = await ai.retrieve({
    retriever: RETRIEVER_REF,
    query: query,
    options: { k: 5 },
  });

  return docs;
}

// 1. Initialization with Custom Cypher Retrieval
neo4j([
  {
    indexId: 'custom-query-idx',
    embedder: googleAI.embedder('gemini-embedding-001'),
    // Override the default RETURN statement.
    // Return the text, plus any graph-derived metrics (like PageRank)
    retrievalQuery: "RETURN node.text AS text, {pagerank: node.pagerankScore, author: node.authorName} AS metadata"
  },
])

import { neo4jParentChildRetrieverRef } from 'genkitx-neo4j';

export async function useParentChildGraphRag(ai: any, userQuery: string) {
  const INDEX_ID = 'graphrag-index';

  // 1. Ingest Data using the bundled Genkit Tool
  // Note: Ensure 'llm-chunk' is installed in your project for this tool to work
  const ingestorTool = ai.tool(`neo4j/${INDEX_ID}/parentChildIngestor`);
  await ingestorTool({
    documents: [{ text: "Massive corporate document text...", metadata: { source: "internal" } }]
  });

  // 2. Retrieve using Parent-Child strategy
  const PC_RETRIEVER_REF = neo4jParentChildRetrieverRef({ indexId: INDEX_ID });

  const parentDocs = await ai.retrieve({
    retriever: PC_RETRIEVER_REF,
    query: userQuery,
    options: { k: 3 }
  });

  return parentDocs;
}

import { neo4jHyDERetrieverRef } from 'genkitx-neo4j';
import { gemini15Flash } from '@genkit-ai/googleai';

// 1. Configuration requires the 'ragModel' parameter
neo4j([
  {
    indexId: 'hyde-index',
    embedder: googleAI.embedder('gemini-embedding-001'),
    ragModel: gemini15Flash // Required to generate the hypothetical answer
  },
])

export async function useHydeGraphRag(ai: any, userQuery: string) {
  const INDEX_ID = 'hyde-index';

  // 2. Ingest Data
  const ingestorTool = ai.tool(`neo4j/${INDEX_ID}/hydeIngestor`);
  await ingestorTool({
    documents: [{ text: "Information about Planet Zeta.", metadata: {} }]
  });

  // 3. Retrieve using HyDE strategy
  const HYDE_RETRIEVER_REF = neo4jHyDERetrieverRef({ indexId: INDEX_ID });

  const hydeDocs = await ai.retrieve({
    retriever: HYDE_RETRIEVER_REF,
    query: userQuery,
    options: { k: 3 }
  });

  return hydeDocs;
}

import { neo4jCustomRetrieverRef } from 'genkitx-neo4j';

// 1. Define custom Cypher traversal during initialization
neo4j([
  {
    indexId: 'custom-rag-index',
    embedder: googleAI.embedder('gemini-embedding-001'),
    customGraphRagConfigs: {
      'sibling-search': {
        systemPrompt: "Use the sibling documents to answer the question.",
        idMetadataKey: "docId",
        cypherIdParamName: "startIds",
        cypherQuery: `
          MATCH (start:Document)-[:SIBLING_OF]->(sibling:Document)
          WHERE start.id IN $startIds
          RETURN sibling.text AS siblingText
        `,
        cypherReturnTextField: "siblingText"
      }
    }
  },
])

// 2. Execute retrieval
export async function useCustomGraphRag(ai: any, userQuery: string) {
  const CUSTOM_RAG_REF = neo4jCustomRetrieverRef({
    indexId: 'custom-rag-index',
    name: 'sibling-search'
  });

  const customRagDocs = await ai.retrieve({
    retriever: CUSTOM_RAG_REF,
    query: userQuery,
    options: { k: 3 }
  });

  return customRagDocs;
}

import { Neo4jSessionStore } from 'genkitx-neo4j';
import { gemini15Flash } from '@genkit-ai/googleai';

export async function startPersistentChat(ai: any, sessionId: string, userMessage: string) {

  // 1. Initialize the Neo4j backed session memory
  const neo4jStore = new Neo4jSessionStore({
    url: 'bolt://localhost:7687',
    username: 'neo4j',
    password: 'password',
  });

  // 2. Control Token Bloat: Only feed the last 10 messages into the LLM context
  neo4jStore.setWindowSize(10);

  // 3. Initialize the chat session
  const chat = ai.chat({
    model: gemini15Flash,
    store: neo4jStore,
    sessionId: sessionId
  });

  // 4. Send message and persist to Graph
  const response = await chat.send(userMessage);
  console.log(response.text);
}

import { Neo4jSessionStore } from 'genkitx-neo4j';

export async function manageChatSessions() {

  // Custom schema configuration
  const customStore = new Neo4jSessionStore({
    url: 'bolt://localhost:7687',
    username: 'neo4j',
    password: 'password',
    sessionLabel: 'AppSession',          // Defaults to 'GenkitSession'
    messageLabel: 'ChatMessage',         // Defaults to 'Message'
    nextMessageRelType: 'THREAD_NEXT',   // Defaults to 'NEXT'
    lastMessageRelType: 'THREAD_HEAD'    // Defaults to 'LAST_MESSAGE'
  });

  const sessionId = 'user-123-session';

  // Programmatically clear/delete all messages and relationships for a session
  await customStore.clear(sessionId);
  console.log(`Session ${sessionId} has been wiped.`);
}