Bahasa IndonesiaTutorial

Panduan API Text-Embedding-3-Small - Panduan Model Embedding OpenAI

Panduan lengkap untuk menggunakan API OpenAI text-embedding-3-small untuk pencarian semantik, sistem RAG, dan pencocokan kemiripan. Termasuk contoh Python, Node.js dan perbandingan harga.

Crazyrouter Team

January 26, 2026 / 369 views

Panduan API Text-Embedding-3-Small - Panduan Model Embedding OpenAI

Crazyrouter

Read the docs Check live pricing Open image tool Create account

Sedang membangun mesin pencari semantik atau sistem RAG (Retrieval-Augmented Generation)? Text-embedding-3-small adalah model embedding terbaru dari OpenAI yang mengonversi teks menjadi vektor numerik, sehingga memungkinkan pencarian kemiripan dan pengambilan konten yang sangat kuat.

Dalam panduan ini, Anda akan mempelajari:

Apa itu text embeddings dan mengapa penting
Cara menggunakan API text-embedding-3-small
Contoh kode lengkap dalam Python dan Node.js
Dimensi kustom untuk penyimpanan yang dioptimalkan
Perbandingan harga dan optimasi biaya

What is Text-Embedding-3-Small?#

Text-embedding-3-small adalah model embedding ringkas dari OpenAI yang dirilis pada Januari 2024. Model ini mengonversi teks menjadi vektor berdimensi 1536 yang menangkap makna semantik, sehingga memungkinkan:

Pencarian Semantik: Menemukan dokumen relevan berdasarkan makna, bukan hanya kata kunci
Sistem RAG: Mengambil konteks untuk respons LLM
Pencocokan Kemiripan: Membandingkan kemiripan teks untuk rekomendasi
Clustering: Mengelompokkan dokumen serupa
Klasifikasi: Mengkategorikan teks berdasarkan konten

Model Specifications#

Specification	Value
Model Name	`text-embedding-3-small`
Default Dimensions	1536
Custom Dimensions	256, 512, 1024, 1536
Max Input Tokens	8,191
Output	Normalized vector

Quick Start#

Prerequisites#

Daftar di Crazyrouter
Dapatkan API key dari dashboard
Python 3.8+ atau Node.js 16+

Python Example#

python

from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Generate embedding for a single text
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Machine learning is transforming industries worldwide."
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")  # Output: 1536
print(f"First 5 values: {embedding[:5]}")

Node.js Example#

javascript

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: 'your-crazyrouter-api-key',
    baseURL: 'https://crazyrouter.com/v1'
});

async function getEmbedding(text) {
    const response = await client.embeddings.create({
        model: 'text-embedding-3-small',
        input: text
    });

    return response.data[0].embedding;
}

// Usage
const embedding = await getEmbedding('Machine learning is amazing');
console.log(`Dimensions: ${embedding.length}`);  // Output: 1536

cURL Example#

bash

curl -X POST https://crazyrouter.com/v1/embeddings \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-embedding-3-small",
    "input": "Hello world"
  }'

Response:

json

{
  "object": "list",
  "model": "text-embedding-3-small",
  "usage": {
    "prompt_tokens": 2,
    "total_tokens": 2
  },
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": [-0.0020785425, -0.049085874, 0.02094679, ...]
    }
  ]
}

Batch Embedding#

Proses beberapa teks dalam satu panggilan API untuk efisiensi yang lebih baik:

python

from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Batch embedding - multiple texts at once
texts = [
    "Python is a programming language",
    "JavaScript runs in browsers",
    "Machine learning uses neural networks"
]

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=texts
)

# Access each embedding
for i, data in enumerate(response.data):
    print(f"Text {i}: {len(data.embedding)} dimensions")

# Output:
# Text 0: 1536 dimensions
# Text 1: 1536 dimensions
# Text 2: 1536 dimensions

Custom Dimensions#

Kurangi biaya penyimpanan dengan menggunakan dimensi yang lebih kecil. Model ini mendukung pengurangan dimensi sambil mempertahankan kualitas:

python

# Use 512 dimensions instead of 1536
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Your text here",
    dimensions=512  # Options: 256, 512, 1024, 1536
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")  # Output: 512

Dimension Comparison#

Dimensions	Storage (per vector)	Use Case
256	1 KB	Aplikasi mobile, penyimpanan terbatas
512	2 KB	Performa seimbang
1024	4 KB	Kebutuhan akurasi tinggi
1536	6 KB	Akurasi maksimum

Building a Semantic Search System#

Berikut contoh lengkap membangun sistem pencarian semantik:

python

import numpy as np
from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

def get_embedding(text):
    """Get embedding for a single text"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    """Calculate cosine similarity between two vectors"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Document database
documents = [
    "Python is great for data science and machine learning",
    "JavaScript is essential for web development",
    "Docker containers simplify deployment",
    "Kubernetes orchestrates container workloads",
    "PostgreSQL is a powerful relational database"
]

# Pre-compute embeddings for all documents
doc_embeddings = [get_embedding(doc) for doc in documents]

# Search function
def search(query, top_k=3):
    query_embedding = get_embedding(query)

    # Calculate similarities
    similarities = [
        cosine_similarity(query_embedding, doc_emb)
        for doc_emb in doc_embeddings
    ]

    # Get top results
    results = sorted(
        zip(documents, similarities),
        key=lambda x: x[1],
        reverse=True
    )[:top_k]

    return results

# Example search
results = search("How to deploy applications?")
for doc, score in results:
    print(f"Score: {score:.4f} - {doc}")

# Output:
# Score: 0.8234 - Docker containers simplify deployment
# Score: 0.7891 - Kubernetes orchestrates container workloads
# Score: 0.6543 - PostgreSQL is a powerful relational database

Integration with Vector Databases#

Pinecone Integration#

python

import pinecone
from openai import OpenAI

# Initialize clients
client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

pinecone.init(api_key="your-pinecone-key")
index = pinecone.Index("your-index")

def embed_and_upsert(texts, ids):
    """Embed texts and store in Pinecone"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts
    )

    vectors = [
        (id, data.embedding)
        for id, data in zip(ids, response.data)
    ]

    index.upsert(vectors=vectors)

def search_pinecone(query, top_k=5):
    """Search Pinecone with query embedding"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=query
    )

    results = index.query(
        vector=response.data[0].embedding,
        top_k=top_k
    )

    return results

ChromaDB Integration#

python

import chromadb
from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Initialize ChromaDB
chroma_client = chromadb.Client()
collection = chroma_client.create_collection("documents")

def get_embeddings(texts):
    """Get embeddings for multiple texts"""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts
    )
    return [data.embedding for data in response.data]

# Add documents
documents = ["doc1 content", "doc2 content", "doc3 content"]
embeddings = get_embeddings(documents)

collection.add(
    embeddings=embeddings,
    documents=documents,
    ids=["doc1", "doc2", "doc3"]
)

# Query
query_embedding = get_embeddings(["search query"])[0]
results = collection.query(
    query_embeddings=[query_embedding],
    n_results=3
)

Available Embedding Models#

Crazyrouter menyediakan akses ke beberapa model embedding OpenAI:

Model	Dimensions	Price Ratio	Best For
`text-embedding-3-small`	1536	0.01	Penggunaan umum, nilai terbaik
`text-embedding-3-large`	3072	0.065	Kebutuhan presisi tinggi
`text-embedding-ada-002`	1536	0.05	Kompatibilitas legacy

Pricing Comparison#

Provider	Model	Price per 1M tokens
OpenAI Official	text-embedding-3-small	$0.020
Crazyrouter	text-embedding-3-small	$0.002
OpenAI Official	text-embedding-3-large	$0.130
Crazyrouter	text-embedding-3-large	$0.013

Catatan harga: Harga yang ditampilkan hanya untuk demonstrasi dan dapat berubah. Penagihan aktual didasarkan pada harga real-time saat permintaan dilakukan.

Contoh Penghematan Biaya:

Untuk sistem RAG yang memproses 10M token/bulan:

OpenAI Official: $200/bulan
Crazyrouter: $20/bulan
Penghematan: 90%

Best Practices#

1. Batch Your Requests#

python

# Good - single API call for multiple texts
response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["text1", "text2", "text3"]  # Up to 2048 texts
)

# Bad - multiple API calls
for text in texts:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )

2. Cache Embeddings#

python

import hashlib
import json

embedding_cache = {}

def get_embedding_cached(text):
    # Create cache key
    cache_key = hashlib.md5(text.encode()).hexdigest()

    if cache_key in embedding_cache:
        return embedding_cache[cache_key]

    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )

    embedding = response.data[0].embedding
    embedding_cache[cache_key] = embedding

    return embedding

3. Use Appropriate Dimensions#

256 dimensions: Aplikasi mobile, perangkat IoT
512 dimensions: Aplikasi web dengan keterbatasan penyimpanan
1024 dimensions: Aplikasi standar
1536 dimensions: Kebutuhan akuratan maksimum

Frequently Asked Questions#

Apa perbedaan antara text-embedding-3-small dan text-embedding-3-large?#

Text-embedding-3-small menghasilkan vektor berdimensi 1536 dan dioptimalkan untuk efisiensi biaya. Text-embedding-3-large menghasilkan vektor berdimensi 3072 dengan akurasi lebih tinggi tetapi dengan biaya 6,5x lebih mahal. Untuk sebagian besar aplikasi, text-embedding-3-small sudah memberikan hasil yang sangat baik.

Can I reduce dimensions after generating embeddings?#

Ya, Anda dapat menggunakan parameter dimensions untuk langsung menghasilkan vektor yang lebih kecil. Ini lebih efisien daripada menghasilkan vektor penuh lalu memotongnya.

Berapa banyak teks yang dapat saya ubah menjadi embedding dalam satu permintaan?#

Anda dapat melakukan embedding hingga 2048 teks dalam satu permintaan API. Untuk dataset besar, lakukan batch permintaan Anda dalam grup berisi 2048.

Are the embeddings normalized?#

Ya, text-embedding-3-small mengembalikan vektor yang ternormalisasi (panjang satu), sehingga Anda dapat menggunakan dot product sebagai pengganti cosine similarity untuk komputasi yang lebih cepat.