retrieve()

retrieve(params: IAIProvidersRetrievalParams): Promise<IAIProvidersRetrievalResult[]>

const documents = [
  {
    content: "London is the capital city of England and the United Kingdom. It is located on the River Thames.",
    meta: { source: "geography.txt", category: "cities" }
  },
  {
    content: "Paris is the capital and most populous city of France. It is situated on the Seine River.",
    meta: { source: "geography.txt", category: "cities" }
  }
];

const results = await aiProviders.retrieve({
  query: "What is the capital of England?",
  documents: documents,
  embeddingProvider: aiProviders.providers[0]
});

// Results are sorted by relevance
results.forEach(result => {
  console.log(`Score: ${result.score}`);
  console.log(`Content: ${result.content}`);
  console.log(`Source: ${result.document.meta?.source}`);
});

// Reading documents from Obsidian vault
const markdownFiles = this.app.vault.getMarkdownFiles();
const documents = [];

// Read content from multiple files
for (const file of markdownFiles.slice(0, 10)) { // Limit for demo
  try {
    const content = await this.app.vault.read(file);
    if (content.trim()) {
      documents.push({
        content: content,
        meta: {
          filename: file.name,
          path: file.path,
          size: content.length,
          modified: file.stat.mtime
        }
      });
    }
  } catch (error) {
    console.warn(`Failed to read ${file.path}:`, error);
  }
}

// Perform semantic search with progress tracking
const results = await aiProviders.retrieve({
  query: "machine learning algorithms",
  documents: documents,
  embeddingProvider: aiProviders.providers[0],
  onProgress: (progress) => {
    const chunksPercentage = (progress.processedChunks.length / progress.totalChunks) * 100;
    const docsPercentage = (progress.processedDocuments.length / progress.totalDocuments) * 100;
    
    console.log(`Processing chunks: ${progress.processedChunks.length}/${progress.totalChunks} (${chunksPercentage.toFixed(1)}%)`);
    console.log(`Processing documents: ${progress.processedDocuments.length}/${progress.totalDocuments} (${docsPercentage.toFixed(1)}%)`);
  }
});

// Results are sorted by relevance score (highest first)
results.forEach(result => {
  console.log(`Score: ${result.score}`);
  console.log(`File: ${result.document.meta?.filename}`);
  console.log(`Content preview: ${result.content.substring(0, 100)}...`);
  console.log(`Path: ${result.document.meta?.path}`);
});

/*
Output example:
Score: 0.92
File: ML-Notes.md
Content preview: Machine learning algorithms can be categorized into supervised, unsupervised, and reinforcement...
Path: Notes/ML-Notes.md

Score: 0.78
File: AI-Research.md
Content preview: Recent advances in neural networks have shown promising results in various applications...
Path: Research/AI-Research.md
*/

const largeDocuments = [
  {
    content: `
      Chapter 1: Introduction to Machine Learning
      Machine learning is a subset of artificial intelligence that focuses on algorithms and statistical models.
      
      Chapter 2: Types of Machine Learning
      There are three main types: supervised learning, unsupervised learning, and reinforcement learning.
      
      Chapter 3: Neural Networks
      Neural networks are computing systems inspired by biological neural networks.
    `,
    meta: { title: "ML Textbook", chapter: "1-3" }
  }
];

const results = await aiProviders.retrieve({
  query: "What are the types of machine learning?",
  documents: largeDocuments,
  embeddingProvider: aiProviders.providers[0]
});

// The method will find the most relevant chunk about ML types
console.log(results[0].content);
// "There are three main types: supervised learning, unsupervised learning, and reinforcement learning."

const results = await aiProviders.retrieve({
  query: "neural networks",
  documents: documents,
  embeddingProvider: aiProviders.providers[0],
  onProgress: (progress) => {
    console.log(`Documents processed: ${progress.processedDocuments.length}/${progress.totalDocuments}`);
    console.log(`Chunks processed: ${progress.processedChunks.length}/${progress.totalChunks}`);
    console.log(`Stage: ${progress.processingType}`);
  }
});

const controller = new AbortController();

try {
  const results = await aiProviders.retrieve({
    query: "search query",
    documents: documents,
    embeddingProvider: aiProviders.providers[0],
    abortController: controller,
    onProgress: (progress) => {
      if (progress.processedChunks.length > 100) {
        controller.abort(); // Cancel if too many chunks
      }
    }
  });
} catch (error) {
  if ((error as Error).message === 'Aborted') {
    console.log('Retrieval cancelled');
  }
}

// 1. Retrieve relevant context
const relevantChunks = await aiProviders.retrieve({
  query: "How do neural networks work?",
  documents: documents,
  embeddingProvider: aiProviders.providers[0]
});

// 2. Build context from top results
const context = relevantChunks
  .slice(0, 3) // Top 3 results
  .map(r => r.content)
  .join('\n\n');

// 3. Generate response with context
const response = await aiProviders.execute({
  provider: aiProviders.providers[0],
  messages: [
    { 
      role: "system", 
      content: "Answer questions based on the provided context." 
    },
    { 
      role: "user", 
      content: `Context:\n${context}\n\nQuestion: How do neural networks work?` 
    }
  ],
  onProgress: (chunk, full) => console.log(full)
});

console.log('RAG Response:', response);

try {
  const results = await aiProviders.retrieve({
    query: "search query",
    documents: documents,
    embeddingProvider: aiProviders.providers[0]
  });
  console.log('Found results:', results.length);
} catch (error) {
  console.error('Retrieval failed:', error);
  // Handle errors (e.g., provider issues, invalid documents)
}