Neo4j Genai Plugin Skill

When to Use

• Generating embeddings inside Cypher without external Python (ai.text.embed())
• Batch-embedding nodes/chunks during ingestion (ai.text.embedBatch())
• Calling LLMs directly in Cypher for completions or GraphRAG (ai.text.completion())
• Extracting structured JSON maps from LLM inside Cypher (ai.text.structuredCompletion())
• Aggregating LLM summaries over grouped rows (ai.text.aggregateCompletion())
• Stateful chat sessions in Cypher (ai.text.chat())
• Counting tokens or chunking text by token limit (ai.text.tokenCount(), ai.text.chunkByTokenLimit())

When NOT to Use

• Python-based GraphRAG pipelines (VectorCypherRetriever, HybridCypherRetriever) → neo4j-graphrag-skill
• Vector index CREATE / kNN search / SEARCH clause → neo4j-vector-index-skill
• GDS embeddings (FastRP, Node2Vec) → neo4j-gds-skill
• Fulltext / keyword search → neo4j-cypher-skill

Prerequisites

CYPHER 25 required for all ai.* functions. Two ways to enable:

cypherCopy code
// Per-query prefix (self-managed, no admin rights needed):
CYPHER 25 MATCH (n:Chunk) ...

// Per-database default (admin; applies to all sessions):
ALTER DATABASE neo4j SET DEFAULT LANGUAGE CYPHER 25

Installation:

• Aura: GenAI plugin enabled by default — no action needed
• Self-managed JAR: copy plugin JAR to plugins/ directory
• Docker: --env NEO4J_PLUGINS='["genai"]'

Provider Config Quick Reference

All ai.text.* functions accept a configuration :: MAP as last argument.

Optional for all: vendorOptions :: MAP passes provider-specific extras (e.g. { dimensions: 1024 } for OpenAI).

❌ Never hardcode API key literals. ✅ Always use $param passed via driver parameters dict.

Full provider config table → references/providers.md

Embedding

Single embed [2025.11]

cypherCopy code
CYPHER 25
MATCH (c:Chunk)
WHERE c.embedding IS NULL
WITH c
CALL {
  WITH c
  SET c.embedding = ai.text.embed(c.text, 'openai', {
    token: $openaiKey,
    model: 'text-embedding-3-small'
  })
} IN TRANSACTIONS OF 500 ROWS

ai.text.embed() returns VECTOR — directly storable and queryable in a vector index.

Batch embed procedure [2025.11]

cypherCopy code
CYPHER 25
MATCH (c:Chunk) WHERE c.embedding IS NULL
WITH collect(c) AS chunks
UNWIND chunks AS c
WITH c.text AS text, c AS node
CALL ai.text.embedBatch(text, 'openai', { token: $openaiKey, model: 'text-embedding-3-small' })
YIELD index, resource, vector
MATCH (c:Chunk {text: resource})
SET c.embedding = vector

Procedure signature: CALL ai.text.embedBatch(resource, provider, config) YIELD index, resource, vector

List configured embed providers

cypherCopy code
CYPHER 25
CALL ai.text.embed.providers()
YIELD name, requiredConfigType, optionalConfigType, defaultConfig
RETURN name, requiredConfigType

Text Completion [2025.11]

cypherCopy code
CYPHER 25
RETURN ai.text.completion(
  'Summarize: ' + $text,
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS summary

Returns STRING.

Aggregate completion — summarize across rows [2026.03]

cypherCopy code
CYPHER 25
MATCH (c:Chunk)-[:PART_OF]->(a:Article {id: $articleId})
RETURN ai.text.aggregateCompletion(
  c.text,
  'Summarize the following article chunks in 3 sentences',
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS summary

value parameter = each row's STRING fed to the LLM. Uses toString() for non-string values.

Pure-Cypher GraphRAG Pattern

Embed question → vector search → graph traverse → LLM completion — all in one Cypher query:

cypherCopy code
CYPHER 25
WITH ai.text.embed($question, 'openai', { token: $openaiKey, model: 'text-embedding-3-small' }) AS qEmbedding
MATCH (chunk:Chunk)
  SEARCH chunk IN (VECTOR INDEX chunk_embedding FOR qEmbedding LIMIT 10) SCORE AS score
// SEARCH preferred on 2026.x; db.index.vector.queryNodes() deprecated 2026.04 — SEARCH syntax → neo4j-vector-index-skill
MATCH (chunk)<-[:HAS_CHUNK]-(article:Article)
OPTIONAL MATCH path = shortestPath((article)-[*..3]-(other:Article))
WITH chunk, article, collect(DISTINCT other.title) AS related, score
ORDER BY score DESC LIMIT 5
WITH collect(chunk.text + '\n[Source: ' + article.title + ']') AS context, $question AS question
RETURN ai.text.completion(
  'Answer based on context:\n' + reduce(s='', c IN context | s + c + '\n') + '\nQuestion: ' + question,
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS answer

Key insight (Bergman): shortest path between seed nodes surfaces relationships not visible from direct neighbors alone.

Structured Output [2026.02]

Returns MAP — directly storable as node properties or used downstream in Cypher.

cypherCopy code
CYPHER 25
MATCH (p:Product {id: $productId})
WITH p,
  ai.text.structuredCompletion(
    'Extract key attributes from: ' + p.description,
    {
      type: 'object',
      properties: {
        category: { type: 'string' },
        tags: { type: 'array', items: { type: 'string' } },
        priceRange: { type: 'string', enum: ['budget', 'mid', 'premium'] }
      },
      required: ['category', 'tags', 'priceRange'],
      additionalProperties: false
    },
    'openai',
    { token: $openaiKey, model: 'gpt-4o-mini' }
  ) AS extracted
SET p.category = extracted.category,
    p.priceRange = extracted.priceRange
WITH p, extracted.tags AS tags
UNWIND tags AS tag
MERGE (t:Tag {name: tag})
MERGE (p)-[:TAGGED]->(t)

Aggregate structured completion — extract across multiple rows [2026.03]

cypherCopy code
CYPHER 25
MATCH (:User {id: $userId})-[:ORDERED]->(o:Order)-[:CONTAINS]->(p:Product)
RETURN ai.text.aggregateStructuredCompletion(
  p.name + ': ' + p.category,
  'Build a shopping profile for this user',
  {
    type: 'object',
    properties: {
      preferredCategories: { type: 'array', items: { type: 'string' } },
      spendingTier: { type: 'string', enum: ['economy', 'standard', 'premium'] }
    },
    required: ['preferredCategories', 'spendingTier']
  },
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS profile

Chat [2025.12]

Supported providers: openai and azure-openai only.

cypherCopy code
// Start new conversation (chatId = null → new session)
CYPHER 25
WITH ai.text.chat(
  'Hello, who are you?',
  null,
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS result
RETURN result.message AS reply, result.chatId AS sessionId

// Continue conversation (pass returned chatId)
CYPHER 25
WITH ai.text.chat(
  'What did I just ask you?',
  $chatId,
  'openai',
  { token: $openaiKey, model: 'gpt-4o-mini' }
) AS result
RETURN result.message AS reply, result.chatId AS sessionId

Returns MAP { message: STRING, chatId: STRING }. Store chatId to continue session.

Tokenization & Chunking [2026.04]

cypherCopy code
// Count tokens before sending to LLM
CYPHER 25
RETURN ai.text.tokenCount($text, 'openai', { token: $openaiKey, model: 'gpt-4o-mini' }) AS tokenCount

// Chunk text by token limit (no external dependencies)
CYPHER 25
UNWIND ai.text.chunkByTokenLimit($longText, 512, 'gpt-4', 50) AS chunk
MERGE (c:Chunk { text: chunk })

// List providers supporting tokenCount
CYPHER 25
CALL ai.text.tokenCount.providers() YIELD name, requiredConfigType
RETURN name, requiredConfigType

Signatures:

• ai.text.tokenCount(input, provider, configuration = {}) :: INTEGER — provider-driven tokenizer; uses provider config (token/model). Local tokenizer for 'openai' (no API call); free API call for 'Bedrock' and 'VertexAI'.
• ai.text.chunkByTokenLimit(input, limit, model = 'gpt-4', overlap = 0) :: LIST<STRING> — local OpenAI tokenizer keyed off model; no provider call, no token required. Chunks by newlines, then spaces, then token count. Set limit below provider max to leave room for prompt overhead.

ai.text.embedBatch [2026.04] supports maxBatchSize (config key) to cap data per API request — defaults to 8192 for 'openai' and 'azure-openai'; no default for 'vertexai' (set if hitting token-limit errors).

Write Gate

SET node.embedding = ai.text.embed(...) and SET node.* = ai.text.structuredCompletion(...) write to the graph.

Before bulk writes:

1. Count nodes first: MATCH (c:Chunk) WHERE c.embedding IS NULL RETURN count(c)
2. Verify config with one test node before batch
3. Use CALL { ... } IN TRANSACTIONS OF 500 ROWS for batches > 1000 nodes
4. Require explicit confirmation before executing

Deprecated — Do NOT Use

Common Errors

Checklist

• CYPHER 25 prefix present on every ai.text.* query
• GenAI plugin installed (Aura: automatic; self-managed: JAR in plugins/)
• API key passed as $param, never as literal string
• model key explicit in config (no silent defaults)
• Provider string lowercase ('openai', 'vertexai', 'bedrock-titan')
• Bulk writes use IN TRANSACTIONS OF 500 ROWS; count target nodes first
• genai.vector.encode() replaced with ai.text.embed() [2025.11+]
• Chat sessions: store returned chatId for continuation; only openai/azure-openai supported
• Structured output schema uses additionalProperties: false to prevent hallucination keys

References

• Full provider config — all required/optional keys per provider
• Official docs
• API reference