Chaînes

import { RetrievalQAChain, VectorRetriever } from '@orka-js/tools';
import { OpenAIAdapter } from '@orka-js/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,          // Inclut les documents sources dans le résultat
  maxSourceTokens: 3000,        // Max de tokens pour la fenêtre de contexte
  systemPrompt: 'Tu es un assistant utile. Réponds uniquement sur la base du contexte fourni.'
});
 
const result = await chain.call('How do I configure authentication?');
 
console.log(result.answer);
// "Pour configurer l'authentification, vous devez..."
 
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 '@orka-js/tools';
 
const chain = new ConversationalRetrievalChain({
  llm,
  retriever,
  collection: 'documentation',
  returnSources: true,
  maxHistoryLength: 10,  // Garde les 10 derniers messages en contexte
  // Optionnel: personnalisez la condensation des questions de suivi
  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:`
});
 
// Première question — récupération normale
const result1 = await chain.call('What authentication methods are supported?');
console.log(result1.answer);
// "Orka JS supporte JWT, OAuth2 et API key authentication..."
 
// Suivi — automatiquement condensé avec l'historique
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);
// "Pour configurer OAuth2, vous devez configurer..."
 
// Un autre suivi
const result3 = await chain.call('What are the required scopes?');
// Condensed to: "What are the required OAuth2 scopes?"
console.log(result3.answer);
// "Les scopes requis sont: openid, profile, email..."
 
// Vérifiez les étapes intermédiaires pour voir la question condensée
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', ... }
// ]
 
// Gérer l'historique
console.log(chain.getChatHistory());
// [{ role: 'user', content: '...' }, { role: 'assistant', content: '...' }, ...]
 
// Réinitialiser la conversation
chain.clearHistory();

import { SummarizationChain } from '@orka-js/tools';
 
// Stuff: tous les documents dans une seule 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);       // Résumé combiné
console.log(result.usage);        // Utilisation des tokens (1 appel LLM)

// Map-Reduce: résume les chunks indépendamment, puis combine
const mapReduceChain = new SummarizationChain({
  llm,
  strategy: 'map-reduce',
  maxChunkSize: 3000,  // Divise les gros documents en chunks de 3000 caractères
  combinePrompt: Combine les résumés suivants en un résumé cohérent:\n\n{{summaries}}\n\nRésumé Combiné:
});
 
const result = await mapReduceChain.call([
  veryLongDocument1,  // 50 000 caractères
  veryLongDocument2   // 30 000 caractères
]);
 
console.log(result.answer);// Résumé combiné final
console.log(result.intermediateSteps);
// [
//   { name: 'map_chunk_0', ... },  // Résumé du chunk 1
//   { name: 'map_chunk_1', ... },  // Résumé du chunk 2
//   ...
//   { name: 'reduce_combine', ... } // Final combined summary
// ]

// Refine: améliore itérativement le résumé avec chaque chunk
const refineChain = new SummarizationChain({
  llm,
  strategy: 'refine',
  maxChunkSize: 3000,
  refinePrompt: `Voici un résumé existant:
{{existingSummary}}
 
Affine ce résumé avec le contexte supplémentaire suivant:
{{context}}
 
Résumé Affiné:`
});
 
const result = await refineChain.call([longDocument]);
 
console.log(result.answer);// Résumé final affiné
console.log(result.intermediateSteps);
// [
//   { name: 'initial_summary', ... },  // Résumé du premier chunk
//   { name: 'refine_1', ... },          // Affiné avec le chunk 2
//   { name: 'refine_2', ... },          // Affiné avec le chunk 3
//   ...
// ]

import { QAChain } from '@orka-js/tools';
 
// Stratégie Stuff (par défaut) — rapide, pour petits ensembles de documents
const stuffQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'stuff',
  returnSources: true
});
 
const result1 = await stuffQA.call(Quel est le taux de limitation?);
 
// Stratégie Map-Reduce — pour de nombreux documents récupérés
const mapReduceQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'map-reduce',
  returnSources: true,
  systemPrompt: Réponds précisément basé sur les documents. Cite les sources quand c'est possible.
});
 
const result2 = await mapReduceQA.call(Compare toutes les méthodes d'authentification);
// Map : extrait les informations pertinentes de chaque document
// Reduce : combine en une réponse complète
 
// Stratégie Refine — meilleure qualité pour questions complexes
const refineQA = new QAChain({
  llm,
  retriever,
  collection: 'docs',
  strategy: 'refine',
  returnSources: true
});
 
const result3 = await refineQA.call(Explique le processus de déploiement complet étape par étape);
// Commence avec la réponse du premier doc, affine avec chaque doc supplémentaire

import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import {
  EnsembleRetriever,
  VectorRetriever,
  BM25Retriever,
  ConversationalRetrievalChain,
  SummarizationChain
} from '@orka-js/tools';
import { MemoryCache, CachedLLM } from '@orka-js/cache';
 
// Configuration avec mise en cache
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 });
 
// Récupérateur hybride (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
});
 
// Chaîne conversationnelle avec récupérateur hybride
const chatChain = new ConversationalRetrievalChain({
  llm,
  retriever: hybrid,
  collection: 'documentation',
  returnSources: true,
  maxHistoryLength: 10
});
 
// Gérer la conversation utilisateur
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
  };
}
 
// Résumer de longs 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;
}

// ✅ Importez uniquement ce dont vous avez besoin
import { RetrievalQAChain } from '@orka-js/tools';
import { ConversationalRetrievalChain } from '@orka-js/tools';
import { SummarizationChain } from '@orka-js/tools';
import { QAChain } from '@orka-js/tools';
 
// ✅ Ou importez depuis l'index
import { RetrievalQAChain, ConversationalRetrievalChain, SummarizationChain, QAChain } from '@orka-js/tools';