Text Embeddings

type MistralEmbeddingModelId = 'mistral-embed' | (string & {});

// Multiple equivalent methods
provider.embedding(modelId: MistralEmbeddingModelId): EmbeddingModelV2<string>;
provider.textEmbedding(modelId: MistralEmbeddingModelId): EmbeddingModelV2<string>;
provider.textEmbeddingModel(modelId: MistralEmbeddingModelId): EmbeddingModelV2<string>;

class MistralEmbeddingModel implements EmbeddingModelV2<string> {
  readonly specificationVersion: 'v2';
  readonly modelId: MistralEmbeddingModelId;
  readonly maxEmbeddingsPerCall: 32;
  readonly supportsParallelCalls: false;
  readonly provider: string;
  
  // Full EmbeddingModelV2 interface implementation
  doEmbed(params: EmbedParams): Promise<EmbedResult>;
}

interface EmbeddingModelV2<string> {
  doEmbed(params: {
    values: string[];
    abortSignal?: AbortSignal;
    headers?: Record<string, string>;
  }): Promise<{
    embeddings: number[][];
    usage?: {
      tokens: number;
    };
  }>;
}

import { mistral } from '@ai-sdk/mistral';

// Create embedding model
const embedder = mistral.textEmbedding('mistral-embed');

// Generate embeddings for multiple texts
const { embeddings, usage } = await embedder.doEmbed({
  values: [
    'The quick brown fox jumps over the lazy dog',
    'Artificial intelligence is transforming technology',
    'Machine learning models process large datasets',
  ],
});

console.log(`Generated ${embeddings.length} embeddings`);
console.log(`Each embedding has ${embeddings[0].length} dimensions`);
console.log(`Token usage: ${usage?.tokens}`);

import { mistral } from '@ai-sdk/mistral';

const embedder = mistral.textEmbedding('mistral-embed');

// Embed your search query
const { embeddings: queryEmbedding } = await embedder.doEmbed({
  values: ['How to train machine learning models?'],
});

// Embed your document collection
const documents = [
  'Machine learning requires quality training data',
  'Neural networks learn patterns from examples',
  'Supervised learning uses labeled datasets',
  'Cooking recipes for Italian cuisine',
];

const { embeddings: docEmbeddings } = await embedder.doEmbed({
  values: documents,
});

// Calculate cosine similarity (simplified example)
function cosineSimilarity(a: number[], b: number[]): number {
  const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
  const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
  const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
  return dotProduct / (magnitudeA * magnitudeB);
}

// Find most similar documents
const similarities = docEmbeddings.map((docEmb, index) => ({
  document: documents[index],
  similarity: cosineSimilarity(queryEmbedding[0], docEmb),
}));

const sortedResults = similarities
  .sort((a, b) => b.similarity - a.similarity)
  .slice(0, 3);

console.log('Most similar documents:', sortedResults);

import { mistral } from '@ai-sdk/mistral';
import { generateText } from 'ai';

async function ragQuery(query: string, documents: string[]) {
  const embedder = mistral.textEmbedding('mistral-embed');
  
  // Embed query and documents
  const [queryResult, docResults] = await Promise.all([
    embedder.doEmbed({ values: [query] }),
    embedder.doEmbed({ values: documents }),
  ]);
  
  // Find most relevant documents (simplified)
  const relevantDocs = documents
    .map((doc, i) => ({
      content: doc,
      similarity: cosineSimilarity(
        queryResult.embeddings[0],
        docResults.embeddings[i]
      ),
    }))
    .sort((a, b) => b.similarity - a.similarity)
    .slice(0, 3)
    .map(item => item.content);
  
  // Use chat model with context
  const { text } = await generateText({
    model: mistral('mistral-large-latest'),
    prompt: `
      Context: ${relevantDocs.join('\n\n')}
      
      Question: ${query}
      
      Answer the question based on the provided context.
    `,
  });
  
  return text;
}

// Usage
const answer = await ragQuery(
  'What are the benefits of machine learning?',
  [
    'Machine learning automates decision-making processes',
    'ML models can identify patterns in large datasets',
    'Artificial intelligence improves over time with more data',
    'Cooking requires proper ingredient preparation',
  ]
);

import { mistral } from '@ai-sdk/mistral';

const embedder = mistral.textEmbedding('mistral-embed');

async function processLargeTextCollection(texts: string[]) {
  const batchSize = 32; // Model's maxEmbeddingsPerCall
  const results: number[][] = [];
  
  for (let i = 0; i < texts.length; i += batchSize) {
    const batch = texts.slice(i, i + batchSize);
    const { embeddings } = await embedder.doEmbed({ values: batch });
    results.push(...embeddings);
    
    // Optional: Add delay to respect rate limits
    if (i + batchSize < texts.length) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }
  
  return results;
}

// Process 100 texts in batches
const largeCollection = Array.from(
  { length: 100 }, 
  (_, i) => `Document ${i + 1}: Sample content here...`
);

const allEmbeddings = await processLargeTextCollection(largeCollection);

import { mistral } from '@ai-sdk/mistral';
import { TooManyEmbeddingValuesForCallError } from '@ai-sdk/provider';

const embedder = mistral.textEmbedding('mistral-embed');

try {
  const tooManyTexts = Array.from({ length: 50 }, (_, i) => `Text ${i}`);
  
  await embedder.doEmbed({ values: tooManyTexts });
} catch (error) {
  if (error instanceof TooManyEmbeddingValuesForCallError) {
    console.error(`Too many values: max ${embedder.maxEmbeddingsPerCall} allowed`);
    // Split into smaller batches
  } else {
    console.error('Embedding error:', error);
  }
}