Embeddings

import { embed } from '@core-ai/core-ai';
import { createOpenAI } from '@core-ai/openai';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
const model = openai.embeddingModel('text-embedding-3-small');

const result = await embed({
  model,
  input: [
    'TypeScript enables safer refactoring.',
    'Runtime validation complements static typing.',
  ],
});

console.log('Embedding count:', result.embeddings.length);
console.log('Vector dimensions:', result.embeddings[0]?.length ?? 0);
console.log('First vector preview:', result.embeddings[0]?.slice(0, 8));
console.log('Usage:', result.usage);

type EmbedResult = {
  embeddings: number[][];  // Array of vectors
  usage?: EmbeddingUsage; // Token usage (if available)
};

type EmbeddingUsage = {
  inputTokens: number;  // Tokens consumed
};

const result = await embed({
  model,
  input: 'Your text here',
  dimensions: 256, // Reduce dimensions for smaller vectors
});

console.log('Dimensions:', result.embeddings[0].length); // 256

import { embed } from '@core-ai/core-ai';

// Cosine similarity function
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);
}

// Embed query and documents
const query = 'What is TypeScript?';
const documents = [
  'TypeScript is a typed superset of JavaScript.',
  'Python is a high-level programming language.',
  'JavaScript runs in web browsers.',
  'TypeScript adds static types to JavaScript.',
];

const result = await embed({
  model,
  input: [query, ...documents],
});

const queryVector = result.embeddings[0];
const docVectors = result.embeddings.slice(1);

// Calculate similarities
const similarities = docVectors.map((docVector, index) => ({
  document: documents[index],
  similarity: cosineSimilarity(queryVector, docVector),
}));

// Sort by similarity
similarities.sort((a, b) => b.similarity - a.similarity);

console.log('Most similar documents:');
similarities.forEach(({ document, similarity }) => {
  console.log(`${similarity.toFixed(4)}: ${document}`);
});

import { embed } from '@core-ai/core-ai';

type Document = {
  id: string;
  text: string;
  embedding?: number[];
};

class SemanticSearch {
  constructor(
    private model: EmbeddingModel,
    private documents: Document[] = []
  ) {}

  async indexDocuments(documents: Document[]): Promise<void> {
    const texts = documents.map((doc) => doc.text);
    const result = await embed({ model: this.model, input: texts });

    this.documents = documents.map((doc, i) => ({
      ...doc,
      embedding: result.embeddings[i],
    }));
  }

  async search(query: string, topK: number = 5): Promise<Document[]> {
    const result = await embed({ model: this.model, input: query });
    const queryVector = result.embeddings[0];

    const scored = this.documents
      .filter((doc) => doc.embedding)
      .map((doc) => ({
        ...doc,
        similarity: cosineSimilarity(queryVector, doc.embedding!),
      }))
      .sort((a, b) => b.similarity - a.similarity)
      .slice(0, topK);

    return scored;
  }
}

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);
}

// Usage
const search = new SemanticSearch(model);

await search.indexDocuments([
  { id: '1', text: 'TypeScript adds static types to JavaScript' },
  { id: '2', text: 'Python is great for data science' },
  { id: '3', text: 'JavaScript runs in web browsers' },
  { id: '4', text: 'TypeScript compiles to JavaScript' },
]);

const results = await search.search('typed JavaScript', 2);
console.log('Search results:', results);

import { embed } from '@core-ai/core-ai';

type Cluster = {
  centroid: number[];
  documents: Array<{ text: string; vector: number[] }>;
};

function kMeansClustering(
  vectors: number[][],
  texts: string[],
  k: number,
  iterations: number = 10
): Cluster[] {
  // Initialize random centroids
  let centroids = vectors.slice(0, k);

  for (let iter = 0; iter < iterations; iter++) {
    // Assign vectors to nearest centroid
    const clusters: Cluster[] = centroids.map((centroid) => ({
      centroid,
      documents: [],
    }));

    vectors.forEach((vector, index) => {
      const similarities = centroids.map((centroid) =>
        cosineSimilarity(vector, centroid)
      );
      const nearest = similarities.indexOf(Math.max(...similarities));
      clusters[nearest].documents.push({ text: texts[index], vector });
    });

    // Update centroids
    centroids = clusters.map((cluster) => {
      const dims = cluster.documents[0].vector.length;
      return Array.from({ length: dims }, (_, i) =>
        cluster.documents.reduce((sum, doc) => sum + doc.vector[i], 0) /
        cluster.documents.length
      );
    });
  }

  return centroids.map((centroid) => ({
    centroid,
    documents: vectors
      .map((vector, index) => ({ text: texts[index], vector }))
      .filter(
        (doc) =>
          centroids.indexOf(
            centroids.reduce((nearest, c) =>
              cosineSimilarity(doc.vector, c) >
              cosineSimilarity(doc.vector, nearest)
                ? c
                : nearest
            )
          ) === centroids.indexOf(centroid)
      ),
  }));
}

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);
}

// Example usage
const documents = [
  'TypeScript adds types to JavaScript',
  'Python is used for data science',
  'JavaScript powers web applications',
  'TypeScript provides better tooling',
  'Python has great ML libraries',
];

const result = await embed({ model, input: documents });
const clusters = kMeansClustering(result.embeddings, documents, 2);

clusters.forEach((cluster, i) => {
  console.log(`\nCluster ${i + 1}:`);
  cluster.documents.forEach((doc) => console.log(`  - ${doc.text}`));
});