OpenAI Latest Embeddings Explained

Code Samples for OpenAI's Text-Embedding-Ada-002

Code Samples for OpenAI's Text-Embedding-Ada-002 with TypeScript

npm install openai dotenv

import { Configuration, OpenAIApi } from "openai";
import dotenv from "dotenv";

dotenv.config();

const openai = new OpenAIApi(
  new Configuration({
    apiKey: process.env.OPENAI_API_KEY, // Store your API key in .env
  })
);

async function generateEmbedding(text: string) {
  const response = await openai.createEmbedding({
    model: "text-embedding-ada-002",
    input: text,
  });

  return response.data.data[0].embedding;
}

// Example Usage
const text = "What is the meaning of life?";
generateEmbedding(text)
  .then((embedding) => console.log("Embedding:", embedding))
  .catch((error) => console.error("Error:", error));

Code Samples for OpenAI's Text-Embedding-Ada-002 with Python

pip install openai python-dotenv

import openai
import os
from dotenv import load_dotenv

# Load API key from .env file
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_embedding(text):
    response = openai.Embedding.create(
        model="text-embedding-ada-002",
        input=text
    )
    return response["data"][0]["embedding"]

# Example Usage
text = "What is the meaning of life?"
embedding = generate_embedding(text)
print("Embedding:", embedding)

🎯 Conclusion By providing both TypeScript and Python examples, developers can seamlessly integrate OpenAI’s Text-Embedding-Ada-002 into their React, Node.js , and Python-based applications. Whether you're building semantic search engines, recommendation systems, or AI-powered assistants, Ada embeddings provide a fast, scalable, and cost-effective solution.

text-embedding-3-small Explained

text-embedding-3-small is a lightweight, high-performance embedding model released by OpenAI in January 2024. It’s part of the new text-embedding-3 family — designed to convert text into high-dimensional vector representations, also known as embeddings.
These embeddings capture semantic meaning, so that similar texts are placed close together in vector space — making it ideal for tasks like:

• 🔥 Semantic Search
• 🔥 Retrieval-Augmented Generation (RAG)
• 🔥 Clustering & classification
• 🔥 Chat memory and context compression
• 🔥 Text deduplication
• 🔥 Recommendation systems

Why is it special?

It supports custom dimensions — you can choose between 256, 512, 1024, or 1536. It's fast, cost-effective, and high-quality, outperforming the previous leader ada-002 on most tasks. It handles above 8000 tokens per request — that's a lot of content per chunk. (8192 tokens) And the best part? It’s built for scale — making it perfect for production systems like:

• 🔥 Knowledge assistants
• 🔥 Search engines
• 🔥 Document indexing tools
• 🔥 and even RAG pipelines for LLMs like GPT-4

How does it perform?

On the MTEB benchmark, text-embedding-3-small delivers state-of-the-art performance for its size and cost — rivaling even larger models like e5-large and bge-large, but with far better speed and affordability.

Let’s take a look at where text-embedding-3-small fits into the current embedding landscape. With an MTEB score between 61 and 63%, it outperforms OpenAI’s previous model ada-002, and holds its own against powerful open models like e5-base-v2. While it may not top the charts like e5-large-v2 or bge-large, it offers a strong balance between quality and ease of use, especially in production systems where latency, token limits, and API integration matter.

In many real-world applications, you don’t need the biggest or the most powerful model — you need the best balance between quality, speed, and cost. And that’s exactly where text-embedding-3-small shines. It’s like the Toyota Corolla of embeddings: not the flashiest, but reliable, efficient, and gets the job done at scale.

Even though it's labeled ‘small’, this model is actually competing with some of the top dogs. For example, e5-large-v2 has a retrieval score of 74.1%, clustering of 64.3%, and classification at 57.4%. Now compare that to text-embedding-3-small — it’s right there in the mix, at 70.2%, 61.2%, and 55.3% respectively.

On top of that, it supports variable dimensionality — from 256 all the way up to 1536 — meaning you can choose whether to optimize for speed, accuracy, or memory. And because it’s fast and lightweight, it’s perfect for production-grade applications like semantic search, recommendation engines, RAG systems, and chat memory compression.

Remember how popular ada-002 was? Well, this model has basically made it obsolete — performing better on nearly every benchmark, and doing so with more control and less cost.
If you’re building a system that needs: Fast and cheap embeddings, Reasonable accuracy across tasks, Easy deployment at scale, …then text-embedding-3-small should be high on your list.

# 🐍 Python (with openai SDK)
import openai

openai.api_key = "your-api-key"

response = openai.Embedding.create(
    model="text-embedding-3-small",
    input="This is a test string",
    dimensions=512  # Optional: choose 256, 512, 1024, or 1536
)

embedding = response["data"][0]["embedding"]
print(embedding)

This Python snippet uses OpenAI’s SDK to generate a vector embedding of a text string using the text-embedding-3-small model. The dimensions parameter lets us control the size of the embedding, which is useful for optimizing storage or performance. You can now easily convert any text into a dense vector with just a few lines of code—perfect for search, clustering, or semantic similarity tasks.

// 🟨 JavaScript (Node.js with openai SDK)
import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "your-api-key"
});

const response = await openai.embeddings.create({
  model: "text-embedding-3-small",
  input: "This is a test string",
  dimensions: 512
});

console.log(response.data[0].embedding);

And here’s the same embedding process in JavaScript using the OpenAI SDK—perfect if you're building with Node.js or working on a full-stack app.

// 🦦 Go (with openai-go SDK)
package main

import ("context", "fmt", "github.com/sashabaranov/go-openai")

func main() {
	client := openai.NewClient("your-api-key")
	resp, err := client.CreateEmbeddings(context.Background(), openai.EmbeddingRequest{
		Model:     openai.TextEmbedding3Small,
		Input:     []string{"This is a test string"},
		Dimensions: 512, // Optional
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Data[0].Embedding)
}

And here it is in Go using the openai-go SDK—ideal for backend services or high-performance applications that need embeddings.

So whether you’re building a semantic search engine, compressing chat history, or powering a RAG system behind your LLM — text-embedding-3-small hits a sweet spot of quality, speed, and price.
It may be small by name — but it’s powerful, scalable, and ready for real-world AI workloads.

Introducing Text-Embedding-3-Large

When accuracy is non-negotiable, meet text-embedding-3-large.
This model boasts a larger network and fixed embedding sizes — for example, 2,048 or 4,096 dimensions — plus a context window up to 16,384 tokens.
It’s roughly three times the cost of 3-small (around $0.00013 per token) but delivers a 67–70% average score on the MTEB benchmark, outperforming smaller variants and even Ada-002.

On-screen comparison table:

OpenAI hosts this model, so you benefit from managed infrastructure and low-latency inference without juggling GPUs yourself.

Customization is where 3-Small shines: tweak dimensions to match your storage and speed needs.
If you need plug-and-play precision, 3-Large’s fixed dimensionGs guarantee consistent results.
Remember: smaller vectors are cheaper and faster; larger ones capture richer semantics.

Let’s look at two demos:
For example
A Product Search that uses (3-Small): Imagine, A retailer uses custom 512-dimensional embeddings to power a lightning-fast semantic search across thousands of SKUs, delivering accurate results under 50ms. or Chatbot Memory that uses (3-Large): Imagine, A customer support bot retrieves context from past user messages in a 10,000-token conversation, ensuring coherent, personalized replies. Watch how 3-Large captures nuances that smaller embeddings might miss, especially for long dialogues.

Upgrading from Ada-002?
If you want to upgrade from ada-002, It’s as easy as swapping model names. But watch out for dimension mismatches — 3-Small’s dynamic dimensions and 3-Large’s fixed sizes differ from Ada-002’s 1,536 dimensions. Also, monitor your costs: 3-Small is cheaper per token, while 3-Large can be pricier but offers higher quality.

Best Practices & Tips

• 🔥 Normalize your embeddings (L2 normalization) for consistent similarity scores.
• 🔥 Batch your requests to maximize throughput within rate limits.
• 🔥 Choose the right index — Faiss for on-prem, probably Pinecone or Qdrant for managed vector databases.
• 🔥 Monitor drift: as your data evolves, periodically retrain or re-embed.