Vercel AI SDK + Neo4j Integration

cd vercel-eve/industry-research-agent
npm install && cp .env.example .env    # add NAMS_API_KEY + OPENAI_API_KEY
npm run chat                           # starts the local MCP server + a terminal chat

cd vercel-eve/industry-research-agent
npm install && cp .env.example .env    # add NAMS_API_KEY + OPENAI_API_KEY
npm run chat                           # local MCP server + terminal chat UI

npm install @ai-sdk/mcp

import { generateText, stepCountIs } from 'ai';
import { createMCPClient } from '@ai-sdk/mcp';

// Basic auth shown here. The notebook's mcp.mjs also supports a Bearer token
// (MCP_BEARER_TOKEN) for OAuth 2.1 servers — see "MCP Authentication" below.
const creds = Buffer.from(`${process.env.NEO4J_USERNAME}:${process.env.NEO4J_PASSWORD}`)
  .toString('base64');

const mcpClient = await createMCPClient({
  transport: {
    type:    'http',
    url:     `http://localhost:${process.env.MCP_PORT}/mcp`,
    headers: { Authorization: `Basic ${creds}` },
  },
});

const mcpTools = await mcpClient.tools();  // get-schema, read-cypher, write-cypher, ...

const { text, steps } = await generateText({
  model,
  system:   'You are a graph database assistant. Run get-schema first if unfamiliar.',
  prompt:   'How many organizations are in the database?',
  tools:    mcpTools,
  stopWhen: stepCountIs(10),   // AI SDK v6+ — replaces the removed maxSteps
});

await mcpClient.close();

LLM: openai / gpt-5.4-mini
[neo4j-mcp] Connected (basic auth) — tools: get-schema, list-gds-procedures, read-cypher, write-cypher
Agent:  neo4j_explorer
Tools:  get-schema, list-gds-procedures, read-cypher, write-cypher

Query: How many organizations are in the database?

Result: There are 46,088 organizations in the database.
[Completed in 3 step(s)]

npm install neo4j-driver

import { generateText, tool, jsonSchema, stepCountIs } from 'ai';
import neo4j from 'neo4j-driver';

const driver = neo4j.driver(
  process.env.NEO4J_URI,
  neo4j.auth.basic(process.env.NEO4J_USERNAME, process.env.NEO4J_PASSWORD),
  { disableLosslessIntegers: true }
);

const getInvestments = tool({
  description: 'Returns investments made by a company.',
  inputSchema: jsonSchema({
    type: 'object',
    properties: {
      company: { type: 'string', description: 'Company or organization name' },
    },
    required: ['company'],
  }),
  execute: async ({ company }) => {
    const { records } = await driver.executeQuery(
      `MATCH (o:Organization)-[:HAS_INVESTOR]->(i)
       WHERE o.name = $company
       RETURN i.id AS id, i.name AS name, head(labels(i)) AS type`,
      { company },
      { database: process.env.NEO4J_DATABASE }
    );
    return records.map(r => r.toObject());
  },
});

// Merge custom tool with MCP tools — the framework routes each call automatically
const { text } = await generateText({
  model,
  prompt:   'Which companies did Google invest in?',
  tools:    { ...mcpTools, getInvestments },
  stopWhen: stepCountIs(10),
});

await driver.close();

Result: Google has made investments in several notable companies:
- Ionic Security
- Avere Systems
- FlexiDAO
- Cloudflare
- Trifacta
[Completed in 4 step(s)]

npm install @neo4j-labs/agent-memory

import { MemoryClient } from '@neo4j-labs/agent-memory';

const memoryClient = new MemoryClient({ apiKey: process.env.MEMORY_API_KEY });
const { id: convId } = await memoryClient.shortTerm.createConversation({ userId: DEMO_USER_ID });

async function buildContext(query) {
  const ctx      = await memoryClient.shortTerm.getContext(convId);
  const entities = await memoryClient.longTerm.searchEntities(query, { limit: 5 });
  // ...format ctx.reflections, ctx.recentMessages and entities into a MEMORY CONTEXT block
}

async function runWithMemory(query) {
  const { text } = await generateText({
    model,
    system:   await buildContext(query),   // BEFORE
    prompt:   query,
    tools:    mcpTools,
    stopWhen: stepCountIs(10),
  });

  // AFTER
  await memoryClient.shortTerm.addMessage(convId, 'user', query);
  await memoryClient.shortTerm.addMessage(convId, 'assistant', text);
  await memoryClient.longTerm.addEntity(`Research: ${query.slice(0, 60)}`, 'concept', {
    description: text.slice(0, 500),
  });
  return text;
}

Memory session: <conversation-id> (workspace: default)

[USER]: I am conducting a competitive analysis of 'Google'. Tell me about their presence in the knowledge graph.
[AGENT]: Google appears in the graph as...
 [Memory] Interaction saved to NAMS ✓

[USER]: Based on our conversation, what subsidiaries of the company we discussed appear in the database?
 ↳ Injecting 1 entity/entities from long-term memory.
 ↳ Injecting context: 2 messages, 1 entities.
[AGENT]: Based on our analysis of Google, the subsidiaries in the database include...
 [Memory] Interaction saved to NAMS ✓

npm install @neo4j-labs/nams-ai-provider

import { createNamsProvider } from '@neo4j-labs/nams-ai-provider';
import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';

const model = createNamsProvider({
  apiKey:       process.env.MEMORY_API_KEY,
  baseProvider: openai,
  scope:        { userId: 'user-1' },
}).languageModel('gpt-5.4-mini');

const { text } = await generateText({ model, prompt: 'What did we discuss last time?' });

const model = createNams({ apiKey }).wrap(openai('gpt-5.4-mini'), { userId: 'user-1' });

import { createNams, enforceQueryMemory } from '@neo4j-labs/nams-ai-provider';
import { ToolLoopAgent, stepCountIs } from 'ai';

const { tools, close } = await createNams({ apiKey }).toolsWithMcp({ userId: 'user-1' }, mcpConfig);

const agent = new ToolLoopAgent({
  model:       openai('gpt-5.4-mini'),
  tools,
  prepareStep: enforceQueryMemory({ graceSteps: 2 }),   // make sure it reads memory first
  stopWhen:    stepCountIs(10),
  onFinish:    async () => { await close(); },
});

const session = createNams({ apiKey }).hooks({ userId: 'user-1' });

const { text } = await generateText({
  model:    openai('gpt-5.4-mini'),
  messages: [...(await session.loadSession()), { role: 'user', content: prompt }],
  onFinish: session.onFinish({ prompt }),
});