Knowledge (RAG)

import { Knowledge } from '@runflow-ai/sdk';

const knowledge = new Knowledge({
  vectorStore: 'support-docs',
  k: 5,
  threshold: 0.7,
});

// Basic search
const results = await knowledge.search('How to reset password?');

results.forEach(result => {
  console.log(result.content);
  console.log('Score:', result.score);
});

// Get formatted context for LLM
const context = await knowledge.getContext('password reset', { k: 3 });
console.log(context);

const agent = new Agent({
  name: 'Support Agent',
  instructions: 'You are a helpful support agent.',
  model: openai('gpt-4o'),
  rag: {
    vectorStore: 'support-docs',
    k: 5,
    threshold: 0.7,

    // Custom search prompt - guides when to search
    searchPrompt: `Use searchKnowledge tool when user asks about:
- Technical problems
- Process questions
- Specific information

Don't use for greetings or casual chat.`,

    toolDescription: 'Search in support documentation for solutions',
  },
});

// Agent automatically has 'searchKnowledge' tool
// LLM decides when to search (not always - more efficient!)
const result = await agent.process({
  message: 'How do I reset my password?',
});

const agent = new Agent({
  name: 'Advanced Support Agent',
  instructions: 'Help users with multiple knowledge bases.',
  model: openai('gpt-4o'),
  rag: {
    vectorStores: [
      {
        id: 'support-docs',
        name: 'Support Documentation',
        description: 'General support articles',
        threshold: 0.7,
        k: 5,
        searchPrompt: 'Use search_support-docs when user has technical problems or questions',
      },
      {
        id: 'api-docs',
        name: 'API Documentation',
        description: 'Technical API reference',
        threshold: 0.8,
        k: 3,
        searchPrompt: 'Use search_api-docs when user asks about API endpoints or integration',
      },
    ],
  },
});

import { Knowledge } from '@runflow-ai/sdk';

const knowledge = new Knowledge({
  vectorStore: 'support-docs',
});

// Add a text document
const result = await knowledge.addDocument(
  'How to reset password: Go to settings > security > reset password',
  {
    title: 'Password Reset Guide',
    category: 'authentication',
    version: '1.0'
  }
);

console.log('Document added:', result.documentId);

import * as fs from 'fs';

// Node.js - Upload from file system
const fileBuffer = fs.readFileSync('./manual.pdf');

const result = await knowledge.addFile(
  fileBuffer,
  'manual.pdf',
  {
    title: 'User Manual',
    mimeType: 'application/pdf',
    metadata: {
      department: 'Support',
      version: '2.0'
    }
  }
);

import * as fs from 'fs';
import { Knowledge } from '@runflow-ai/sdk';

const knowledge = new Knowledge({ vectorStore: 'product-catalog' });

// Fire-and-forget: returns as soon as the job is accepted (HTTP 202)
const { jobId } = await knowledge.ingestFile(
  fs.readFileSync('./catalog.csv'),
  'catalog.csv',
  { mimeType: 'text/csv' }
);

// Poll whenever you want
const job = await knowledge.getIngestionJob(jobId);
console.log(job.status, `${job.processedChunks}/${job.totalChunks}`);

const result = await knowledge.ingestFile(
  fs.readFileSync('./catalog.csv'),
  'catalog.csv',
  {
    mimeType: 'text/csv',
    waitForCompletion: true,
    onProgress: (job) => console.log(`${Math.round(job.progress * 100)}%`),
  }
);

console.log('Indexed', result.job?.processedChunks, 'chunks');

await knowledge.ingestFile(fs.readFileSync('./catalog.csv'), 'catalog.csv', {
  mimeType: 'text/csv',
  csv: {
    delimiter: ';',                       // sniffed automatically when omitted
    contentColumns: ['name', 'brand'],    // embedded (default: all columns)
    metadataColumns: ['sku', 'price'],    // copied to each document's metadata
  },
});

await knowledge.ingestFile(file, 'export.csv', {
  hygiene: {
    stripHtml: true,            // strip tags, decode entities
    removeUrls: true,           // drop URLs from content
    dropEmptyValues: true,      // remove "-", "n/a", "..." placeholder fields
    normalizeWhitespace: true,  // collapse repeated spaces/newlines
    dedupeUnits: true,          // drop duplicate rows/chunks
  },
});

const results = await knowledge.search('reset password', {
  k: 5,
  filters: {
    category: 'authentication',
    language: 'en',
  },
});

const results = await knowledge.search('pricing plans', {
  k: 10,
  filters: {
    version: { value: "2.0", operator: '>=' },
    status: 'published',
  },
});

const agent = new Agent({
  name: 'Support Agent',
  model: openai('gpt-4o'),
  rag: {
    vectorStore: 'support-docs',
    k: 5,
    threshold: 0.7,
    filters: {
      department: 'support',
      status: 'published',
    },
  },
});

const agent = new Agent({
  name: 'Smart Agent',
  model: openai('gpt-4o'),
  rag: {
    vectorStore: 'docs',
    k: 10,
    
    // Interceptor: Customize results before LLM
    onResultsFound: async (results, query) => {
      // Filter sensitive data
      const filtered = results.filter(r => !r.metadata?.internal);
      
      // Enrich with external data
      const enriched = await Promise.all(
        filtered.map(async r => ({
          ...r,
          content: `${r.content}\n\nSource: ${r.metadata?.url}`,
        }))
      );
      
      return enriched;
    },
  },
});