Chains

import { RetrievalQAChain } from 'orkajs/chains/retrieval-qa';
import { VectorRetriever } from 'orkajs/retrievers/vector';
import { OpenAIAdapter } from 'orkajs/adapters/openai';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
const retriever = new VectorRetriever({
  llm,
  vectorDB: myVectorDB,
  topK: 5
});
 
const chain = new RetrievalQAChain({
  llm,
  retriever,
  collection: 'documentation',
  returnSources: true,          // Include source documents in result
  maxSourceTokens: 3000,        // Max tokens for context window
  systemPrompt: 'You are a helpful assistant. Answer based ONLY on the provided context.'
});
 
const result = await chain.call('How do I configure authentication?');
 
console.log(result.answer);
// "To configure authentication, you need to..."
 
console.log(result.sources);
// [{ id: 'doc-1', score: 0.92, content: '...' }, ...]
 
console.log(result.intermediateSteps);
// [
//   { name: 'retrieve', input: '...', output: 'Found 5 relevant documents', latencyMs: 120 },
//   { name: 'generate', input: '...', output: '...', latencyMs: 850 }
// ]
 
console.log(result.usage);
// { promptTokens: 1200, completionTokens: 350, totalTokens: 1550 }

import { ConversationalRetrievalChain } from 'orkajs/chains/conversational-retrieval';
 
const chain = new ConversationalRetrievalChain({
  llm,
  retriever,
  collection: 'documentation',
  returnSources: true,
  maxHistoryLength: 10,  // Keep last 10 messages in context
  // Optional: customize how follow-up questions are condensed
  condenseQuestionPrompt: `Given the following conversation and a follow-up question,
rephrase the follow-up as a standalone question.
 
Chat History:
{{history}}
 
Follow-up: {{question}}
 
Standalone Question:`
});
 
// First question — normal retrieval
const result1 = await chain.call('What authentication methods are supported?');
console.log(result1.answer);
// "Orka AI supports JWT, OAuth2, and API key authentication..."
 
// Follow-up — automatically condensed with history
const result2 = await chain.call('How do I configure the second one?');
// Internally condensed to: "How do I configure OAuth2 authentication?"
console.log(result2.answer);
// "To configure OAuth2, you need to set up..."
 
// Another follow-up
const result3 = await chain.call('What are the required scopes?');
// Condensed to: "What are the required OAuth2 scopes?"
console.log(result3.answer);
 
// Check intermediate steps to see the condensed question
console.log(result2.intermediateSteps);
// [
//   { name: 'condense_question', input: 'How do I configure the second one?',
//     output: 'How do I configure OAuth2 authentication?' },
//   { name: 'retrieve', ... },
//   { name: 'generate', ... }
// ]
 
// Manage history
console.log(chain.getChatHistory());
// [{ role: 'user', content: '...' }, { role: 'assistant', content: '...' }, ...]
 
chain.clearHistory();  // Reset conversation

import { SummarizationChain } from 'orkajs/chains/summarization';
 
// Stuff: all documents in one prompt
const stuffChain = new SummarizationChain({
  llm,
  strategy: 'stuff',
  systemPrompt: 'Provide a clear and concise summary.'
});
 
const result = await stuffChain.call([
  'Document 1 content here...',
  'Document 2 content here...',
  'Document 3 content here...'
]);
 
console.log(result.answer);       // Combined summary
console.log(result.usage);        // Token usage (1 LLM call)

// Map-Reduce: summarize chunks independently, then combine
const mapReduceChain = new SummarizationChain({
  llm,
  strategy: 'map-reduce',
  maxChunkSize: 3000,  // Split large docs into 3000-char chunks
  combinePrompt: 'Combine the following summaries into a single coherent summary:\n\n{{summaries}}\n\nCombined Summary:'
});
 
const result = await mapReduceChain.call([
  veryLongDocument1,  // 50,000 chars
  veryLongDocument2   // 30,000 chars
]);
 
console.log(result.answer);
console.log(result.intermediateSteps);
// [
//   { name: 'map_chunk_0', ... },  // Summary of chunk 1
//   { name: 'map_chunk_1', ... },  // Summary of chunk 2
//   ...
//   { name: 'reduce_combine', ... } // Final combined summary
// ]

// Refine: iteratively improve summary with each chunk
const refineChain = new SummarizationChain({
  llm,
  strategy: 'refine',
  maxChunkSize: 3000,
  refinePrompt: `Here is an existing summary:
{{existingSummary}}
 
Refine this summary with the following additional context:
{{context}}
 
Refined Summary:`
});
 
const result = await refineChain.call([longDocument]);
 
console.log(result.answer);
console.log(result.intermediateSteps);
// [
//   { name: 'initial_summary', ... },  // First chunk summary
//   { name: 'refine_1', ... },          // Refined with chunk 2
//   { name: 'refine_2', ... },          // Refined with chunk 3
//   ...
// ]

import { QAChain } from 'orkajs/chains/qa';
 
// Stuff strategy (default) — fast, for small document sets
const stuffQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'stuff',
  returnSources: true
});
 
const result1 = await stuffQA.call('What is the rate limit?');
 
// Map-Reduce strategy — for many retrieved documents
const mapReduceQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'map-reduce',
  returnSources: true,
  systemPrompt: 'Answer precisely based on the documents. Cite sources when possible.'
});
 
const result2 = await mapReduceQA.call('Compare all authentication methods');
// Map: extracts relevant info from each document
// Reduce: combines into a comprehensive answer
 
// Refine strategy — best quality for complex questions
const refineQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'refine',
  returnSources: true
});
 
const result3 = await refineQA.call('Explain the complete deployment process step by step');
// Starts with answer from first doc, refines with each additional doc

import { createOrka } from 'orkajs/core';
import { OpenAIAdapter } from 'orkajs/adapters/openai';
import { EnsembleRetriever, VectorRetriever, BM25Retriever } from 'orkajs/retrievers';
import { ConversationalRetrievalChain, SummarizationChain } from 'orkajs/chains';
import { MemoryCache } from 'orkajs/cache/memory';
import { CachedLLM } from 'orkajs/cache/llm';
 
// Setup with caching
const baseLLM = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
const llm = new CachedLLM(baseLLM, new MemoryCache({ maxSize: 500 }));
 
const orka = createOrka({ llm, vectorDB: myVectorDB });
 
// Hybrid retriever (BM25 + Vector)
const hybrid = new EnsembleRetriever({
  retrievers: [
    new BM25Retriever({ documents: myDocs, topK: 10 }),
    new VectorRetriever({ llm, vectorDB: myVectorDB, topK: 10 })
  ],
  weights: [0.3, 0.7],
  topK: 5
});
 
// Conversational chain with hybrid retrieval
const chatChain = new ConversationalRetrievalChain({
  llm,
  retriever: hybrid,
  collection: 'documentation',
  returnSources: true,
  maxHistoryLength: 10
});
 
// Handle user conversation
async function handleMessage(userMessage: string) {
  const result = await chatChain.call(userMessage);
 
  return {
    answer: result.answer,
    sources: result.sources?.map(s => ({
      id: s.id,
      score: s.score,
      preview: s.content?.slice(0, 100)
    })),
    steps: result.intermediateSteps
  };
}
 
// Summarize long documents
const summarizer = new SummarizationChain({
  llm,
  strategy: 'map-reduce',
  maxChunkSize: 3000
});
 
async function summarizeDocuments(texts: string[]) {
  const result = await summarizer.call(texts);
  return result.answer;
}

// ✅ Import only what you need
import { RetrievalQAChain } from 'orkajs/chains/retrieval-qa';
import { ConversationalRetrievalChain } from 'orkajs/chains/conversational-retrieval';
import { SummarizationChain } from 'orkajs/chains/summarization';
import { QAChain } from 'orkajs/chains/qa';
 
// ✅ Or import from index
import { RetrievalQAChain, ConversationalRetrievalChain, SummarizationChain, QAChain } from 'orkajs/chains';