Build a RAG Pipeline with JavaScript / Node.js

mkdir foxnose-rag && cd foxnose-rag
npm init -y
npm install @foxnose/sdk openai dotenv

{
  "type": "module"
}

OPENAI_API_KEY=sk-...
FOXNOSE_ENV_KEY=your-environment-key            # Your FoxNose Environment Key
FOXNOSE_PUBLIC_KEY=your-public-key              # Your Flux API public key
FOXNOSE_SECRET_KEY=your-secret-key              # Your Flux API secret key

import 'dotenv/config'
import { FluxClient, SimpleKeyAuth } from '@foxnose/sdk'

export function getFluxClient(apiPrefix) {
  return new FluxClient({
    baseUrl: `https://${process.env.FOXNOSE_ENV_KEY}.fxns.io`,
    apiPrefix,
    auth: new SimpleKeyAuth(
      process.env.FOXNOSE_PUBLIC_KEY,
      process.env.FOXNOSE_SECRET_KEY,
    ),
  })
}

/**
 * Searches a FoxNose folder for relevant content.
 *
 * @param {string} apiPrefix - The Flux API prefix (e.g., 'my_api').
 * @param {string} folderPath - Path to the folder to search (e.g., 'knowledge-base').
 * @param {string} query - The natural language search query.
 * @param {object} [options]
 * @param {'vector'|'hybrid'|'text'} [options.mode='hybrid'] - Search mode.
 * @param {number} [options.topK=5] - Maximum number of results to return.
 * @param {number} [options.similarityThreshold=0.7] - Minimum similarity score (0-1).
 * @param {object} [options.filters] - Optional structured filters.
 * @param {string} [options.contentField='body'] - Field containing main content.
 * @param {string} [options.titleField='title'] - Field containing the title.
 * @param {string} [options.urlField='url'] - Field containing the source URL.
 */
export async function searchKnowledgeBase(
  apiPrefix,
  folderPath,
  query,
  {
    mode = 'hybrid',
    topK = 5,
    similarityThreshold = 0.7,
    filters = null,
    contentField = 'body',
    titleField = 'title',
    urlField = 'url',
  } = {},
) {
  const client = getFluxClient(apiPrefix)

  // Build the search request body
  const body = { limit: topK }

  if (mode === 'vector') {
    body.search_mode = 'vector'
    body.vector_search = {
      query,
      top_k: topK,
      similarity_threshold: similarityThreshold,
    }
  } else if (mode === 'hybrid') {
    body.search_mode = 'hybrid'
    body.find_text = { query }
    body.vector_search = {
      query,
      top_k: topK,
      similarity_threshold: similarityThreshold,
    }
  } else {
    body.find_text = { query }
  }

  // Add structured filters if provided
  if (filters) {
    body.where = {
      $: { all_of: Object.entries(filters).map(([k, v]) => ({ [k]: v })) },
    }
  }

  // Execute the search
  const response = await client.search(folderPath, body)
  client.close()

  // Parse results
  return (response.results ?? []).map((resource) => ({
    key: resource._sys?.key ?? '',
    title: resource.data?.[titleField] ?? 'Untitled',
    content: resource.data?.[contentField] ?? '',
    url: resource.data?.[urlField] ?? null,
  }))
}

import 'dotenv/config'
import OpenAI from 'openai'
import { searchKnowledgeBase } from './foxnose-client.mjs'

const openai = new OpenAI()

// Configure which API and folder to search (adjust for your setup)
const API_PREFIX = 'my_api'
const FOLDER_PATH = 'path/to/knowledge-base'

function buildPromptContext(results) {
  if (results.length === 0) {
    return 'No relevant information was found in the knowledge base.'
  }

  return results
    .map((result, i) => {
      let sourceInfo = `[Source ${i + 1}: ${result.title}]`
      if (result.url) sourceInfo += ` (${result.url})`
      return `${sourceInfo}\n${result.content}`
    })
    .join('\n\n---\n\n')
}

/**
 * Asks a question, retrieves context from FoxNose, and generates an answer using an LLM.
 *
 * @param {string} question - The user's question.
 * @param {object} [options]
 * @param {number} [options.topK=5] - Maximum number of results to return.
 * @param {number} [options.similarityThreshold=0.7] - Minimum similarity score.
 * @param {object} [options.filters] - Optional structured filters.
 * @returns {Promise<{answer: string, sources: Array}>}
 */
export async function ask(
  question,
  { topK = 5, similarityThreshold = 0.7, filters = null } = {},
) {
  // 1. Retrieve relevant context from your FoxNose knowledge base
  console.log(`Searching for context related to: '${question}'...`)
  const results = await searchKnowledgeBase(API_PREFIX, FOLDER_PATH, question, {
    mode: 'hybrid',
    topK,
    similarityThreshold,
    filters,
  })

  // 2. Build the context string to be injected into the LLM prompt
  const context = buildPromptContext(results)

  // 3. Generate a grounded answer using the LLM and the retrieved context
  const systemPrompt = `You are a helpful assistant that answers questions based ONLY on the provided context.
- If the context doesn't contain the answer, state that you don't have enough information.
- Be concise and direct.
- When possible, cite the source title and include the URL so users can read more.`

  const userPrompt = `Context:\n${context}\n\nQuestion: ${question}\n\nAnswer:`

  console.log('Generating answer with LLM...')
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userPrompt },
    ],
    temperature: 0,
  })

  const answer = response.choices[0].message.content

  // 4. Return the final answer and the source documents for verification
  return {
    answer,
    sources: results.map((r) => ({ key: r.key, title: r.title, url: r.url })),
  }
}

import { createInterface } from 'node:readline/promises'
import { ask } from './rag.mjs'

async function main() {
  const rl = createInterface({
    input: process.stdin,
    output: process.stdout,
  })

  console.log('FoxNose RAG Q&A System')
  console.log("Type 'quit' or 'exit' to stop.\n")

  while (true) {
    const question = (await rl.question('Question: ')).trim()

    if (['quit', 'exit'].includes(question.toLowerCase())) break
    if (!question) continue

    const result = await ask(question)

    console.log(`\nAnswer: ${result.answer}\n`)

    if (result.sources.length > 0) {
      console.log('Sources:')
      for (const source of result.sources) {
        if (source.url) {
          console.log(`  - ${source.title}: ${source.url}`)
        } else {
          console.log(`  - ${source.title} (ID: ${source.key})`)
        }
      }
    }
    console.log('-'.repeat(40))
  }

  rl.close()
}

main()

node main.mjs

// In rag.mjs, modify the ask() function signature:

export async function ask(
  question,
  { topK = 5, similarityThreshold = 0.7, category = null } = {},
) {
  // Build a filter object if a category is provided
  const filters = category ? { category__eq: category } : null

  const results = await searchKnowledgeBase(API_PREFIX, FOLDER_PATH, question, {
    mode: 'hybrid',
    topK,
    similarityThreshold,
    filters,
  })

  // ... the rest of the function remains the same
}

// A general question
await ask('How do I reset my password?')

// A constrained question filtered by category
await ask('What\'s our return policy?', { category: 'policies' })

npm install @foxnose/langchain @langchain/openai langchain

import 'dotenv/config'
import { FluxClient, SimpleKeyAuth } from '@foxnose/sdk'
import { FoxNoseRetriever } from '@foxnose/langchain'
import { ChatOpenAI } from '@langchain/openai'
import { ChatPromptTemplate } from '@langchain/core/prompts'
import { createStuffDocumentsChain } from 'langchain/chains/combine_documents'
import { createRetrievalChain } from 'langchain/chains/retrieval'

const client = new FluxClient({
  baseUrl: `https://${process.env.FOXNOSE_ENV_KEY}.fxns.io`,
  apiPrefix: 'my_api',
  auth: new SimpleKeyAuth(
    process.env.FOXNOSE_PUBLIC_KEY,
    process.env.FOXNOSE_SECRET_KEY,
  ),
})

const retriever = new FoxNoseRetriever({
  client,
  folderPath: 'knowledge-base',
  pageContentField: 'body',
  searchMode: 'hybrid',
  topK: 5,
})

const llm = new ChatOpenAI({ model: 'gpt-4o', temperature: 0 })

const prompt = ChatPromptTemplate.fromTemplate(
  `Answer the user's question based only on the following context:

{context}

Question: {input}

Answer:`,
)

const combineDocsChain = await createStuffDocumentsChain({ llm, prompt })
const chain = await createRetrievalChain({
  retriever,
  combineDocsChain,
})

// Example usage
const result = await chain.invoke({ input: 'How do I reset my password?' })
console.log(result.answer)

console.log('\nSources:')
for (const doc of result.context) {
  console.log(`  - ${doc.metadata.title}`)
}