Text Embeddings

/**
 * Generate text embeddings using AWS Bedrock embedding models
 */
class BedrockEmbeddings extends Embeddings implements BedrockEmbeddingsParams {
  constructor(fields?: BedrockEmbeddingsParams);
  
  /** Generate embedding for a single document/query */
  embedQuery(document: string): Promise<number[]>;
  
  /** Generate embeddings for multiple documents in parallel */
  embedDocuments(documents: string[]): Promise<number[][]>;
  
  /** Internal method for embedding text with retry logic */
  protected _embedText(text: string): Promise<number[]>;
}

import { BedrockEmbeddings } from "@langchain/aws";

// Basic initialization
const embeddings = new BedrockEmbeddings({
  region: "us-east-1",
  model: "amazon.titan-embed-text-v1",
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
  }
});

// Embed a single query
const queryEmbedding = await embeddings.embedQuery(
  "What is the capital of France?"
);
console.log(queryEmbedding.length); // 1536 for Titan v1

// Embed multiple documents
const documents = [
  "Paris is the capital of France.",
  "London is the capital of England.",
  "Berlin is the capital of Germany."
];

const documentEmbeddings = await embeddings.embedDocuments(documents);
console.log(documentEmbeddings.length); // 3
console.log(documentEmbeddings[0].length); // 1536 for each embedding

interface BedrockEmbeddingsParams extends EmbeddingsParams {
  /** Embedding model to use (default: "amazon.titan-embed-text-v1") */
  model?: string;
  
  /** Custom BedrockRuntimeClient instance */
  client?: BedrockRuntimeClient;
  
  /** Configuration options for BedrockRuntimeClient */
  clientOptions?: BedrockRuntimeClientConfig;
  
  /** AWS region for API calls */
  region?: string;
  
  /** AWS credentials for authentication */
  credentials?: CredentialType;
}

// Using Titan v2
const titanV2 = new BedrockEmbeddings({
  region: "us-east-1",
  model: "amazon.titan-embed-text-v2:0"
});

// Using Cohere multilingual
const cohereMulti = new BedrockEmbeddings({
  region: "us-east-1",
  model: "cohere.embed-multilingual-v3"
});

// Test different models
const text = "Machine learning is transforming industries";
const titanEmbedding = await titanV2.embedQuery(text);
const cohereEmbedding = await cohereMulti.embedQuery(text);

console.log("Titan dimensions:", titanEmbedding.length);
console.log("Cohere dimensions:", cohereEmbedding.length);

import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";

// Custom client with specific configuration
const customClient = new BedrockRuntimeClient({
  region: "us-west-2",
  credentials: {
    accessKeyId: "your-access-key",
    secretAccessKey: "your-secret-key"
  },
  maxAttempts: 3,
  requestHandler: {
    connectionTimeout: 5000,
    socketTimeout: 60000
  }
});

const embeddings = new BedrockEmbeddings({
  client: customClient,
  model: "amazon.titan-embed-text-v1"
});

// Configure client options without providing custom client
const embeddings = new BedrockEmbeddings({
  region: "us-east-1",
  model: "amazon.titan-embed-text-v1",
  clientOptions: {
    maxAttempts: 5,
    requestHandler: {
      connectionTimeout: 10000,
      socketTimeout: 120000
    }
  }
});

class BedrockEmbeddings {
  /** Maximum batch size for processing documents (default: 512) */
  batchSize: number;
}

// Configure batch size
const embeddings = new BedrockEmbeddings({
  region: "us-east-1",
  model: "amazon.titan-embed-text-v1"
});

embeddings.batchSize = 100; // Process 100 documents at a time

// Process large document set
const largeDocumentSet = Array.from({ length: 1000 }, (_, i) => 
  `Document ${i + 1}: This is sample content for document number ${i + 1}.`
);

// Embeddings will be processed in batches automatically
const embeddings_result = await embeddings.embedDocuments(largeDocumentSet);
console.log(`Processed ${embeddings_result.length} documents`);

// Text with various formatting will be automatically cleaned
const messyText = `
This is a document
with multiple lines
and    extra    spaces.

It has paragraph breaks too.
`;

const embedding = await embeddings.embedQuery(messyText);
// Text is automatically cleaned: "This is a document with multiple lines and extra spaces. It has paragraph breaks too."

try {
  const embedding = await embeddings.embedQuery("Sample text");
} catch (error) {
  if (error.message.includes("credentials")) {
    console.error("Authentication failed - check AWS credentials");
  } else if (error.message.includes("region")) {
    console.error("Invalid region - check AWS region configuration");
  } else if (error.message.includes("model")) {
    console.error("Model not available - check model ID and region support");
  } else {
    console.error("Embedding failed:", error.message);
  }
}

// Handle document batch errors
try {
  const embeddings_result = await embeddings.embedDocuments([
    "Valid document",
    "", // Empty document might cause issues
    "Another valid document"
  ]);
} catch (error) {
  console.error("Batch embedding failed:", error.message);
  // Retry with individual documents to identify problematic ones
}

// Create embeddings for vector search
const documents = [
  "Artificial intelligence is transforming healthcare",
  "Machine learning models require large datasets",
  "Deep learning uses neural networks with multiple layers",
  "Natural language processing enables computers to understand text"
];

const docEmbeddings = await embeddings.embedDocuments(documents);

// Store in vector database (pseudo-code)
const vectorStore = new VectorDatabase();
documents.forEach((doc, index) => {
  vectorStore.add({
    id: index,
    text: doc,
    embedding: docEmbeddings[index]
  });
});

// Query for similar documents
const query = "How does AI help in medical applications?";
const queryEmbedding = await embeddings.embedQuery(query);

// Find similar documents (pseudo-code)
const similarDocs = vectorStore.similaritySearch(queryEmbedding, { limit: 3 });

// Efficient batch processing
const embeddings = new BedrockEmbeddings({
  region: "us-east-1", // Use closest region
  model: "amazon.titan-embed-text-v1"
});

// Process in optimal batch sizes
const batchSize = 50; // Adjust based on your needs
const allDocuments = [...]; // Your document array

const allEmbeddings = [];
for (let i = 0; i < allDocuments.length; i += batchSize) {
  const batch = allDocuments.slice(i, i + batchSize);
  const batchEmbeddings = await embeddings.embedDocuments(batch);
  allEmbeddings.push(...batchEmbeddings);
}

// Monitor token usage
const embeddings = new BedrockEmbeddings({
  region: "us-east-1",
  model: "amazon.titan-embed-text-v1"
});

// Estimate tokens (rough approximation: 1 token ≈ 4 characters)
function estimateTokens(text: string): number {
  return Math.ceil(text.length / 4);
}

const documents = ["Document 1", "Document 2", "Document 3"];
const totalTokens = documents.reduce((sum, doc) => sum + estimateTokens(doc), 0);
console.log(`Estimated tokens: ${totalTokens}`);

// Consider text truncation for very long documents
const maxTokens = 8000; // Leave buffer for model limits
const truncatedDocs = documents.map(doc => {
  const estimatedTokens = estimateTokens(doc);
  if (estimatedTokens > maxTokens) {
    // Rough truncation - in production, use proper tokenization
    const maxChars = maxTokens * 4;
    return doc.substring(0, maxChars);
  }
  return doc;
});

const embeddings_result = await embeddings.embedDocuments(truncatedDocs);