Coder Legion - Recent posts tagged embedding-models

Understanding Semantic Search: Vector Embeddings and Similarity Search

Mon, 02 Feb 2026 07:14:35 +0000

Semantic search represents a fundamental shift in how we retrieve information from databases and search engines. Unlike traditional keyword-based search that relies on exact text matches, semantic search understands the meaning and context behind queries, enabling more intuitive and accurate information retrieval.

What is Semantic Search?

Semantic search goes beyond keyword matching to understand the intent and contextual meaning behind a query. Instead of looking for exact word matches, it retrieves results based on semantic similarity—finding content that means the same thing, even when different words are used.

For example, searching for "healthy dinner ideas" could return results like "nutritious meal prep for busy nights" even though the exact keywords don't match. This is possible because semantic search operates on the underlying meaning of the content.

Understanding Vector Data Distribution

Vector embeddings, which power semantic search, have unique characteristics:

Uneven Distribution

Vector data points are not uniformly distributed across vector space. Instead, they cluster around regions of semantic similarity, reflecting how related concepts group together in meaning.

Semantic Clustering

Vectors representing similar concepts naturally cluster together:

Words like "king," "queen," "prince," and "princess" form a royalty cluster
Technical terms like "algorithm," "function," and "code" cluster in programming regions
Synonyms and semantically related phrases position close to each other

This clustering property is fundamental to how semantic search works—we find related content by finding nearby vectors in this space.

How Similarity Search Works: k-NN Principle

At its core, semantic search relies on k-Nearest Neighbors (k-NN) search. When you perform a similarity search:

Convert your query into a vector embedding
Find the k nearest vectors to your query vector in the vector space
Retrieve the corresponding documents or data points

The result is an ordered list ranked by similarity, with the most semantically similar items appearing first.

Distance Metrics

Similarity between vectors is measured using:

Cosine Similarity: Measures the angle between vectors (commonly used for text)
Euclidean Distance: Straight-line distance between points
Dot Product: Useful for normalized vectors
Manhattan Distance: Sum of absolute differences along each dimension

Types of Similarity Search

1. Exact Search (Exhaustive Search)

How It Works: Compares the query vector against every single vector in the database.

Characteristics:

Accuracy: 100% accurate—guarantees finding actual nearest neighbors
Speed: Slow for large datasets (can take hours for millions of vectors)
Use Cases: Small datasets (< 10,000 documents) or when perfect accuracy is critical

2. Approximate Search (ANN)

How It Works: Uses specialized algorithms (like HNSW, IVF, or LSH) to efficiently search through large datasets by narrowing down the search space.

Characteristics:

Accuracy: High accuracy (typically 90-99%)
Speed: Dramatically faster—searches that take 65 hours with exact search complete in seconds
Use Cases: Large datasets (hundreds of thousands to billions of vectors)

Popular ANN Algorithms:

HNSW: Graph-based, extremely fast for queries
IVF: Cluster-based, good for very large datasets
LSH: Hash-based, excellent for high-dimensional data

Aspect	Exact Search	Approximate Search
Accuracy	100%	90-99%
Speed	Slow (linear)	Fast (sub-linear)
Scalability	Poor for large datasets	Excellent
Best For	< 10K documents	> 10K documents

Vector Embedding Models

Vector embeddings are the "translation layer" that converts human-readable content into machine-understandable numerical representations.

What Are Embedding Models?

Embedding models are machine learning models—typically based on transformer architectures—that convert data into dense vector representations trained on massive datasets to understand semantic relationships.

Key Capabilities

Contextual Understanding: Assign meaning based on context (e.g., "bank" in "river bank" vs. "financial bank" gets different embeddings)

Feature Extraction: Identify and quantify relevant features:

In text: semantic meaning, sentiment, topic
In images: shapes, colors, textures, objects
In audio: pitch, rhythm, timbre, speech patterns

Transformer Architecture: Excel at processing sequences, capturing long-range dependencies, and parallel processing for efficiency.

Popular Models

For Text:

Sentence Transformers (all-MiniLM-L6-v2): 384 dimensions, fast and lightweight
BERT: 768 dimensions, general-purpose language understanding
GPT Embeddings (text-embedding-ada-002): 1536 dimensions, production-grade

For Images:

CLIP: Jointly embeds images and text in the same space
ResNet: Deep convolutional neural network for image features
ViT: Transformer-based image understanding

For Audio:

Wav2Vec 2.0: Speech and audio embeddings
CLAP: Contrastive Language-Audio Pre-training

Types of Embedding Models

1. Pre-trained Open Source Models

Advantages: Zero training cost, proven performance, large community support

When to Use: General semantic search, quick prototyping, resource-constrained environments

Examples: Sentence Transformers library (15,000+ models), BERT variants, Universal Sentence Encoder

2. Custom Models Based on Your Dataset

Advantages: Optimal performance for specific use cases, understands proprietary terminology

Process: Start with pre-trained model → Fine-tune on labeled data → Evaluate → Iterate

Use Cases: Medical terminology, legal documents, e-commerce catalogs, scientific research

Generating Vector Embeddings

1. Outside the Database

Third-Party APIs: OpenAI, Cohere, Google Vertex AI, Hugging Face

Local Inference: Python libraries (sentence-transformers, transformers), ONNX Runtime, TensorFlow/PyTorch

Example:

from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(["Semantic search is powerful"])

Advantages: Flexibility in model choice, control over pipeline

Disadvantages: Requires additional infrastructure, data movement between systems

2. Within the Database (ONNX)

ONNX (Open Neural Network Exchange) is an open format enabling models trained in one framework to be deployed in another.

Supported Databases: Oracle Database 23ai, PostgreSQL (with extensions), Microsoft SQL Server, SingleStore

Example (Oracle):

BEGIN
  DBMS_VECTOR.LOAD_ONNX_MODEL(
    directory => 'MODEL_DIR',
    file_name => 'all-MiniLM-L6-v2.onnx',
    model_name => 'text_embedding_model'
  );
END;

Advantages: No data movement, reduced latency, simplified architecture

Disadvantages: Limited to ONNX-compatible models, database computational overhead

Factor	External Generation	In-Database (ONNX)
Model Flexibility	High	Medium
Latency	Higher	Lower
Data Security	Requires data export	Data stays in DB
Best For	Batch processing, custom models	Real-time apps, integrated systems

Real-World Applications

Document Search: Find relevant documents based on meaning rather than keywords
Recommendation Systems: Suggest products/content based on similarity
Question Answering: Match user questions to relevant answers
Content Moderation: Identify similar or duplicate content
Image Search: Enable search by visual similarity
Customer Support: Route tickets and find similar past issues
Fraud Detection: Identify unusual patterns
Code Search: Find similar code snippets or search by natural language

Performance Optimization Tips

Choose the Right Balance: Use exact search for < 10K documents, approximate for > 100K
Tune Parameters: Adjust ef_search (HNSW) or nprobe (IVF) for accuracy vs. speed
Optimize Dimensions: Choose appropriate dimension counts, consider quantization
Implement Caching: Cache frequent embeddings, pre-compute for static content
Batch Processing: Generate embeddings in batches, leverage GPU acceleration

Key Takeaways

Vector embeddings capture semantic meaning in numerical form
Vector data naturally clusters by semantic similarity
Choose between exact search (accurate, slow) and approximate search (fast, 90-99% accurate) based on your needs
Transformer-based embedding models provide state-of-the-art semantic understanding
Models can be pre-trained, custom-trained, or fine-tuned for specific domains
Embeddings can be generated externally or within databases using ONNX

Whether you're building a search engine, recommendation system, or AI-powered application, understanding these concepts is crucial for leveraging the full power of modern semantic search technologies.

RAG Pipeline Deep Dive: Ingestion, Chunking, Embedding, and Vector Search

Wed, 21 Jan 2026 06:23:00 +0000

Retrieval-Augmented Generation (RAG) has become the default approach for providing context and memory to AI applications. Understanding the RAG pipeline—from document ingestion to final response generation—is essential for building high-performance AI systems. This comprehensive guide explores each stage of the RAG workflow, with special focus on Oracle Database 23ai's native vector capabilities.

The RAG Pipeline: An Overview

A complete RAG pipeline consists of two main phases:

Ingestion Phase (Offline):
Documents → Chunking → Embedding → Index/Store in Vector Database

Retrieval Phase (Runtime):
User Query → Embed Query → Similarity Search → Top-K Results → LLM Generation → Response

The RAG pipeline connects the model to the information it needs at query time. When a user asks a question, the pipeline retrieves the most relevant documents, prepares that text as context, and includes it in the prompt so the model can generate an answer grounded in retrieved material rather than training data alone.

Phase 1: Document Ingestion

Ingestion is the process of loading documents from multiple sources and in multiple formats, transforming them into a structured form suitable for embedding and retrieval.

Document Loading

Raw documents—whether PDFs, Word documents, web pages, or database records—must be transformed into manageable chunks suitable for retrieval.

Common Sources:

Local files (PDF, DOCX, TXT, CSV)
Web pages and APIs
Databases and data warehouses
Cloud storage (S3, GCS, Azure Blob)
Enterprise systems (SharePoint, Confluence, Notion)

Loading Libraries:

PyPDF2: For PDF documents
python-docx: For Word documents
LangChain Document Loaders: Unified interface for multiple formats
LlamaIndex Data Connectors: Specialized loaders for various sources
Oracle OracleDocLoader: Native loader for Oracle Database 23ai

Text Extraction and Cleaning

A clean corpus improves both retrieval accuracy and embedding quality. Use parsing libraries to extract only the primary content from web pages or PDFs, and remove boilerplate, navigation links, and disclaimers.

Cleaning Steps:

Remove Noise: Headers, footers, navigation, ads
Normalize Structure: Convert to consistent format (JSONL, Parquet)
Preserve Metadata: Source, timestamp, author, document type
Handle Special Characters: Normalize encoding (UTF-8)
Maintain Logical Structure: Keep headings, lists, tables

Metadata Enrichment

Each chunk should carry metadata such as topic, date, and source, so that retrieval can filter and rank results more effectively.

Important Metadata Fields:

source_id: Unique document identifier
title: Document title
created_date: Document creation timestamp
author: Document creator
document_type: PDF, email, webpage
topic/category: For domain filtering
page_number: For PDF sources
chunk_id: Unique identifier for the chunk

Phase 2: Chunking - The Critical Step

Chunking is simply the act of splitting larger documents into smaller units ("chunks"). Each chunk can be individually indexed, embedded, and retrieved.

Why Chunking Matters

The chunking process directly feeds into the embedding step, where each chunk is converted into vector representations that capture semantic meaning.

A common source of inaccurate or unstable answers lies in a structural conflict within the traditional "chunk-embed-retrieve" pipeline: using a single-granularity, fixed-size text chunk to perform two inherently conflicting tasks:

Semantic matching (recall): Smaller chunks (100-256 tokens) needed for precise similarity search
Context understanding (utilization): Larger chunks (1024+ tokens) needed for coherent LLM generation

This creates a difficult trade-off between "precise but fragmented" and "complete but vague."

Pre-Chunking vs Post-Chunking

Pre-chunking is the most common method. It processes documents asynchronously by breaking them into smaller pieces before embedding and storing them in the vector database. This enables fast retrieval at query time since all chunks are pre-computed.

Post-chunking takes a different approach by embedding entire documents first, then performing chunking at query time only on the documents that are actually retrieved. The chunked results can be cached, so the system becomes faster over time.

Chunking Strategies

Fixed-Length Chunking: This is the simplest approach, segmenting text into equally sized pieces using character, token, or word counts.

Common Chunk Sizes:

300-500 tokens: Typical chunks for most use cases, depending on the model and content type
100-256 tokens: For high-precision recall in semantic search
1024+ tokens: For providing complete context to LLMs

Adopt recursive/semantic chunkers with 10-20% overlap to maintain context across boundaries.

Advanced Chunking Approaches:

Recursive Chunking: This method is a bit smarter. It splits text hierarchically based on cues like paragraphs, line breaks, or sentences. If a section is too long, it recursively divides it further.

Semantic Chunking: Instead of letting token limits decide where ideas get chopped, it uses embeddings to detect where the meaning actually shifts—grouping semantically related sentences together.

Document-Aware Chunking: Preserves document structure (sections, paragraphs, tables) while chunking.

Chunk Overlap

Chunk overlap is the number of overlapping characters (or tokens) between adjacent chunks. This ensures that context isn't lost when information spans chunk boundaries.

Recommended Overlap:

10-20% overlap is standard practice
For 500-token chunks, use 50-100 token overlap
Maintains continuity without excessive redundancy

Example:

Chunk 1: [Tokens 0-500]
Chunk 2: [Tokens 450-950]  ← 50 token overlap
Chunk 3: [Tokens 900-1400] ← 50 token overlap

Splitting Process

Documents are split recursively until the chunks are small enough, using text splitters that respect:

Sentence boundaries (don't break mid-sentence)
Paragraph boundaries (maintain logical grouping)
Section boundaries (preserve document structure)

Popular Chunking Libraries:

The LLM community often turns to two powerful open-source libraries: LangChain and LlamaIndex:

LangChain: Broad framework with flexible chunking strategies
LlamaIndex: Designed specifically for RAG pipelines with sophisticated NodeParsers
Chonkie: Lightweight, dedicated chunking library focusing solely on text splitting

Phase 3: Embedding and Storage

Chunking makes information retrievable; embeddings make it searchable by meaning rather than keywords.

What Are Embeddings?

Embeddings are numerical representations that capture semantic relationships between text. A piece of text—whether a word, phrase, sentence, or paragraph—is converted to a vector of numbers (typically 384-1536 dimensions).

Key Properties:

Semantic similarity: Embeddings that are numerically similar are also semantically similar
Dense representation: High-dimensional vectors capture nuanced meaning
Model-specific: Different embedding models produce different vector spaces

Embedding Models

Popular Options:

OpenAI text-embedding-3-large: 3072 dimensions, high quality
Cohere embed-v4.0: 1024 dimensions, multimodal (text + images)
Sentence-BERT (SBERT): 768 dimensions, open-source
all-MiniLM-L6-v2: 384 dimensions, lightweight and fast

Choose MiniLM/SBERT/Instruct/E5 for text, CLIP for images. Normalize embeddings for consistent similarity calculations.

Embedding Generation: Outside vs Inside the Database

Option 1: Generate Embeddings Outside Oracle Database 23ai

Vector embeddings can be generated outside Oracle Database 23ai using third-party embedding models, then imported into the database for storage and search.

Workflow:

from sentence_transformers import SentenceTransformer

# Load embedding model
model = SentenceTransformer('all-MiniLM-L6-v2')

# Generate embeddings
chunks = ["First chunk text", "Second chunk text"]
embeddings = model.encode(chunks)

# Store in Oracle Database 23ai
# INSERT INTO documents (text, embedding) VALUES (?, ?)

Advantages:

Flexibility in choosing any embedding model
Can use cloud-based embedding services
Easy integration with existing ML pipelines

Option 2: Generate Embeddings Inside Oracle Database 23ai

Embeddings can also be generated inside Oracle Database 23ai by downloading pretrained embedding models, converting them to ONNX format, and importing the ONNX format models into Database 23ai.

ONNX (Open Neural Network Exchange) is an open-source format designed to represent deep learning models. It aims to provide interoperability between different deep learning frameworks.

Process:

Download Pretrained Model from Hugging Face or similar source
Convert to ONNX Format using Oracle OML4Py utility
Import into Database 23ai using DBMS_VECTOR package

The command can be run to import the ONNX file into the database:

EXEC dbms_vector.load_onnx_model(
  'DM_DUMP',
  'all_MiniLM_L12_v2.onnx',
  'minilm_l12_v2',
  JSON('{"function": "embedding", "embeddingOutput": "embedding", "input": {"input": ["DATA"]}}')
);

Generate Embeddings in SQL:

SELECT VECTOR_EMBEDDING(minilm_l12_v2 USING 'Your text here' AS data) AS embedding
FROM DUAL;

Advantages:

Oracle Database implements an ONNX runtime directly within the database. This allows you to generate vector embeddings directly within Oracle Database using SQL
Eliminates data movement between systems
Simplified architecture and security
Native integration with Oracle's vector capabilities

Phase 4: Vector Indexes for Fast Search

Once embeddings are generated and stored, vector indexes are specialized data structures designed for similarity searches in high-dimensional vector spaces. They help accelerate vector similarity searches by reducing the number of distance calculations needed.

Why Vector Indexes?

Exact search to find the closest matches for a given vector are accurate but can be slow, since costly vector distance computations are needed for all vectors in a column.

Vector indexes use techniques like clustering, partitioning, and neighbor graphs to group similar vectors together, reducing the search space dramatically.

Oracle AI Vector Search: Supported Index Types

Oracle AI Vector Search supports Hierarchical Navigable Small World (HNSW) indexes and Inverted File (IVF) indexes.

1. HNSW: In-Memory Neighbor Graph

Hierarchical Navigable Small World (HNSW) creates a navigable graph structure to locate similar vectors with exceptional speed and accuracy.

Characteristics:

HNSW is an In-Memory Neighbor Graph Vector Index fully built in-memory. You need to setup a new memory pool with VECTOR_MEMORY_SIZE in the SGA to accommodate it.

Since the HNSW index consumes a lot of memory, Oracle Database 23ai makes this index available by allocating a memory area called Vector Pool.

Memory Calculation:

To roughly determine the memory size needed to store an HNSW index, use the following formula: 1.3 × number of vectors × number of dimensions × size of your vector dimension type (for example, a FLOAT32 is 4 bytes).

Creating HNSW Index:

-- Configure vector pool
ALTER SYSTEM SET vector_memory_size=800M SCOPE=SPFILE;
-- Restart required

-- Create HNSW index
CREATE VECTOR INDEX documents_hnsw_idx 
ON documents (embedding)
ORGANIZATION NEIGHBOR GRAPH
DISTANCE COSINE
WITH TARGET ACCURACY 95;

Performance:

HNSW enables sub-100ms retrieval at 95%+ recall—extremely fast for real-time applications.

Limitations:

DML operations (insert, update, delete) are not allowed after creating an HNSW index—designed for read-heavy workloads.

HNSW indexes are not available in RAC environments.

2. IVF: Neighbor Partition Index

Inverted File Flat (IVF) indexes partition data points into clusters, enabling efficient searching within relevant clusters.

Characteristics:

IVF Flat index is a Neighbor Partition Vector index built on disk, and its blocks are cached in the regular buffer cache.

A significant advantage of an IVF vector index is that it is not constrained by the amount of memory available in the vector pool like an HNSW vector index is.

How IVF Works:

It is designed to enhance search efficiency by narrowing the search area through the use of neighbor partitions or clusters. The center of each partition, or the centroid, represents the average vector for each partition. By default, the number of partitions and their corresponding centroids is set to the square root of the dataset's size.

Creating IVF Index:

CREATE VECTOR INDEX documents_ivf_idx 
ON documents (embedding)
ORGANIZATION NEIGHBOR PARTITIONS
DISTANCE COSINE
WITH TARGET ACCURACY 95;

Advantages:

Works with massive datasets
Supports global and local indexes on partitioned tables
DML operations can degrade accuracy over time. Periodically rebuilding the index may be necessary
More memory-efficient than HNSW

Performance:

Although an IVF index won't be as fast as an equivalent HNSW index, it can be used for very large data sets and still provide excellent performance when compared to an exhaustive similarity search.

3. Hybrid Vector Indexes

Hybrid vector index combines full text and semantic search in one index, allowing users to easily index and query their documents using a combination of full text search and semantic vector search.

Use Case:
When you need to match both semantic meaning AND specific keywords/terms in a single query.

GPU Acceleration

At Oracle CloudWorld 2024, Oracle demonstrated GPU-accelerated creation of vector embeddings and HNSW index creation using NVIDIA GPUs.

When a user sends a request to create an HNSW vector index to Oracle Database, the database intelligently compiles and redirects the task to a Compute Offload Server process that leverages GPUs and the CAGRA algorithm from NVIDIA cuVS library to rapidly generate a graph index.

Phase 5: Retrieval - Finding Relevant Context

At runtime, when a user submits a query, the retrieval phase locates the most relevant chunks to provide as context to the LLM.

Query Embedding

The system encodes the user's query with the same model used to embed documents during ingestion.

-- Generate query embedding
SELECT VECTOR_EMBEDDING(minilm_l12_v2 USING 'What is RAG?' AS data) AS query_vector
FROM DUAL;

Similarity Search

The query vector is compared against all document vectors in the database using a distance metric.

Distance Metrics:

Common options include EUCLIDEAN, L2_SQUARED, COSINE, DOT, MANHATTAN, and HAMMING. You can specify the metric during index creation or within the search query itself.

Cosine Similarity: Most common for text (measures angle between vectors)
Euclidean Distance: Straight-line distance in vector space
Dot Product: Efficient for normalized vectors

Performing Similarity Search:

SELECT 
  text,
  VECTOR_DISTANCE(embedding, :query_vector, COSINE) AS distance
FROM documents
ORDER BY distance
FETCH APPROX FIRST 5 ROWS ONLY;

Top-K Results

The system searches the index for the nearest vectors, retrieves the top-k chunks, and includes those chunks with the query in the prompt.

Choosing K:

K=3-5: For focused, specific queries
K=10-20: For broader research queries
K=50+: For comprehensive document analysis

Challenges:

Top-k returns near duplicates or shallow snippets, so the prompt lacks diversity. Retrieval misses proper nouns, IDs, or acronyms because they occur rarely.

Solutions:

Reranking: Rerank with cross-encoders (Cohere ReRank, ColBERT) when precision matters
Hybrid Search: Combine BM25 (keyword) with dense vectors to boost tail recall
Metadata Filtering: Filter by date, source, document type before retrieval

Monitoring Index Accuracy

A valuable feature is Oracle's provision of functions to report index accuracy based on query vectors used in approximate searches. This allows you to continuously monitor and optimize the accuracy of your vector search implementation.

Phase 6: Generation - Creating the Final Response

Once relevant chunks are retrieved, they're combined with the user's query and sent to an LLM for response generation.

Prompt Assembly

Retrieved chunks are formatted into a coherent context block:

Context:
[Chunk 1 text]
[Chunk 2 text]
[Chunk 3 text]

Question: [User query]

Answer based on the provided context:

LLM Generation

The complete prompt (context + query) is sent to the LLM, which generates a response grounded in the retrieved information rather than relying solely on parametric knowledge.

Benefits:

Reduces hallucinations
Provides traceable sources
Enables up-to-date information
Maintains factual accuracy

Best Practices for Production RAG Pipelines

1. Optimize Chunking Strategy

Align chunk size with context windows, use task-specific sentence transformers, and default to HNSW + metadata filtering for sub-100ms retrieval at 95%+ recall.

2. Choose Appropriate Embedding Models

Match embedding dimensions to your dataset size
Consider domain-specific models for specialized content
Test multiple models and measure retrieval quality

3. Implement Proper Indexing

Small-Medium datasets (< 1M vectors): HNSW for maximum speed
Large datasets (1M+ vectors): IVF for scalability
Keyword + Semantic: Hybrid vector indexes

4. Monitor and Iterate

Monitor recall@k, latency, and index memory; re-embed on model upgrades.

Track metrics:

Retrieval accuracy (precision@k, recall@k)
Query latency (p50, p95, p99)
Index build time
Storage requirements

5. Handle Edge Cases

Query reformulation for better retrieval
Fallback strategies when retrieval fails
Confidence thresholds for generated responses
Citation and source tracking

Advanced RAG Techniques

1. Self-Correction (CRAG)

When strong retrieval pipelines return incomplete or irrelevant context, CRAG adds a lightweight feedback loop: before generating, the system checks whether the retrieved set is good enough. If it looks weak, the system triggers another retrieval pass.

2. Agentic RAG

Agentic RAG systems plan retrieval strategies and iterate based on partial results—dynamically deciding what to retrieve next.

3. GraphRAG

Build an advanced RAG system by first structuring data into a knowledge graph, then layering graph-aware retrieval to capture entity relationships.

4. Multimodal RAG

Combining text, images, audio, and video retrieval for richer context.

A robust RAG pipeline requires careful attention to every stage:

Ingestion: Clean, structured data with rich metadata
Chunking: Balanced chunk sizes with appropriate overlap (10-20%)
Embedding: Semantic representations using appropriate models
Indexing: Fast similarity search with HNSW or IVF indexes
Retrieval: Accurate top-K results with metadata filtering
Generation: Grounded responses with proper citations

Oracle Database 23ai provides a complete, integrated platform for RAG with native vector support, ONNX model runtime, advanced indexing (HNSW, IVF, Hybrid), and SQL-native operations—eliminating the need for separate vector databases.

By mastering these components and following best practices, you can build production-grade RAG systems that deliver accurate, relevant, and trustworthy AI-powered experiences.

Chat and Embedding Models in OCI Generative AI

Tue, 16 Dec 2025 08:45:24 +0000

Oracle Cloud Infrastructure (OCI) Generative AI provides two powerful categories of models: chat models for conversational AI and text generation, and embedding models for semantic understanding and search. Understanding how to configure and optimize these models is essential for building effective AI applications.

Understanding Tokens

Before diving into model parameters, it's crucial to understand that LLMs understand tokens rather than characters. A token can be a word, part of a word, or even punctuation. As a general rule, estimate approximately 4 characters per token—meaning 100 tokens is roughly 60-80 words.

This matters because all LLM limits, costs, and parameters are expressed in tokens, not words or characters.

Chat Models: Configuration Parameters

Chat models in OCI Generative AI offer extensive configuration options to control their behavior and output characteristics.

Max Output Tokens

The maximum number of tokens that you want the model to generate per response. Each model has different maximum output token limits specified in their key features.

Important: Because you're prompting a chat model, the response depends on the prompt and each response doesn't necessarily use up the maximum allocated tokens. Setting this parameter essentially creates a ceiling—the model will stop generating once it hits this limit.

Preamble Override

An initial context or guiding message for a chat model that changes the model's overall chat behavior and conversation style. When you don't provide a preamble, the model uses its default.

Default Preamble for Cohere Command R Family:

You are Command. You are an extremely capable large language model built by Cohere. 
You are given instructions programmatically via an API that you follow to the best 
of your ability.

Custom Preamble Example:

You are a helpful assistant specialized in Italian cuisine. 
Respond with enthusiasm and include regional context when discussing dishes.

With this preamble override, when asked about cannolis, the model responds with regional details about Sicily and specific bakeries like Caffe Sierra and Pasticceria Cappello.

Alternative Approach: You can also include preamble-like instructions directly in your conversation. For example: "Answer the following question in a marketing tone. Where's the best place to go sailing?"

Temperature

Temperature controls the randomness of the output. It's one of the most important parameters for shaping model behavior.

How Temperature Works:

Temperature modulates the probability distribution over words in the vocabulary
Temperature = 0: Makes the model deterministic, always selecting the word with the highest probability (essentially greedy decoding)
Low temperature (< 1.0): Distribution is more peaked around the most likely tokens, producing focused, predictable outputs
Temperature = 1.0: Standard probability distribution with no modification
High temperature (> 1.0): Distribution flattens across all words, increasing randomness and creativity

Best Practices:

Start with temperature set to 0 or less than one, and increase it as you regenerate prompts for more creative output. Be cautious: high temperatures can introduce hallucinations and factually incorrect information.

Use Cases:

Low temperature (0.0-0.3): Code generation, factual Q&A, technical documentation
Medium temperature (0.5-0.7): General chatbots, customer service, balanced responses
High temperature (0.8-1.0+): Creative writing, brainstorming, diverse idea generation

Top-K Sampling

Top-K tells the model to pick the next token from the top K tokens in its list sorted by probability.

A higher value for K generates more random output, making the text sound more natural. The parameter essentially limits the selection pool to the K most likely candidates at each step.

Range:

Minimum: 1 (considers only the single most probable token, essentially deterministic)
Maximum: Vocabulary size (considers all possible tokens)
OCI Default: 0 for Command models, -1 for Llama models (meaning the model considers all tokens and doesn't use this method)

Example: If K=3 and the top three tokens are:

"favorite" (40% probability)
"best" (30% probability)
"preferred" (15% probability)

The model randomly selects from only these three options, weighted by their probabilities.

Top-P (Nucleus Sampling)

Top-P is similar to Top-K but picks from top tokens based on the sum of their probabilities. It's more dynamic than Top-K because the number of tokens considered varies.

Top-P selects tokens whose cumulative probability exceeds a threshold (p), limiting the pool to the smallest set meeting this sum.

How It Works:

Top-P picks the next token based on cumulative probability, ensuring the sum of probabilities is below a certain threshold.

Example: If Top-P = 0.5 and tokens have probabilities:

Token A: 0.3 (30%)
Token B: 0.2 (20%)
Token C: 0.1 (10%)

The model only considers A and B (cumulative 50%), excluding C.

Range:

Minimum: 0.0 (considers only the single most probable token)
Maximum: 1.0 (considers all tokens)

A high top-p value means the model looks at more possible words, even less likely ones, making generated text more diverse.

Practical Guidelines:

Top-P = 0.5: Only considers words adding up to 50% probability—focused responses
Top-P = 0.9: Includes many more words—varied and original responses

The Interaction: Temperature, Top-K, and Top-P

The selection process works in stages: Top-K tokens with highest probabilities are sampled first, then tokens are further filtered based on Top-P, with the final token being selected using temperature.

Decision Framework:

For tasks requiring accuracy and focus (like code completion), use lower temperature, higher Top-P/Top-K, and moderate max tokens
For creative writing, experiment with higher temperature, lower Top-P/Top-K, and larger max token limits

Frequency and Presence Penalties

These parameters are useful if you want to get rid of repetition in your outputs.

Frequency Penalty:
A penalty assigned to a token when that token appears frequently. High penalties encourage fewer repeated tokens and produce more random output.

Presence Penalty:
A penalty assigned to each token when it appears in the output to encourage generating outputs with tokens that haven't been used.

Use Case: If your model keeps repeating the same phrases or concepts, increase these penalties to encourage more diverse vocabulary and concepts.

Seed Parameter (Reproducibility)

Assigning a number for the seed parameter is similar to tagging the request with a number. The LLM aims to generate the same set of tokens for the same integer in consecutive requests.

Important Notes:

Allowed values are integers; assigning large or small seed values doesn't affect the result
Especially useful for debugging and testing
Warning: The seed parameter might not produce the same result long-term because model updates might invalidate the seed

OCI Limits:

API: No maximum value
Console: Maximum value is 9999
Leave blank (Console) or null (API) to disable

Stop Sequences

A sequence of characters—such as a word, phrase, newline (\n), or period—that tells the model when to stop the generated output.

Example: If the stop sequence is a period (.), the model stops generating text once it reaches the end of the first sentence, even if the token limit is much higher.

Use Case: Useful for controlling output length and format, especially when you want responses limited to single sentences or specific sections.

Likelihood Display

Shows how likely a token is to follow the current generated token. Likelihood is defined by a number between -15 and 0, where more negative numbers mean less likely tokens.

Example: The word "favorite" is more likely to be followed by "food" or "book" rather than "zebra."

Important: This parameter doesn't influence the generation process itself but serves as a diagnostic tool to help understand the model's behavior.

Embedding Models: Converting Text to Vectors

Embedding models transform text into numerical representations that capture semantic meaning, enabling AI systems to understand relationships between words, sentences, and documents.

What Are Embeddings?

Embeddings are numerical representations of text converted to number sequences. A piece of text can be a phrase, sentence, or one or more paragraphs.

A vector embedding is a mapping from input (like a word, list of words, or image) into a list of floating-point numbers. That list represents the input in the multidimensional embedding space of the model.

OCI Embedding Model Dimensions

OCI Generative AI embedding models transform each phrase, sentence, or paragraph into an array with 384 (light models) or 1024 numbers, depending on the embedding model selected.

Available Models:

Cohere Embed English V3: 1024 dimensions
Cohere Embed English Light V3: 384 dimensions
Cohere Embed Multilingual V3: 1024 dimensions
Cohere Embed Multilingual Light V3: 384 dimensions
Cohere Embed 4: Latest version supporting text and images

Trade-offs:

Light models (384d): Faster processing, lower memory usage, suitable for most applications
Standard models (1024d): Richer semantic representation, better for complex similarity tasks

Types of Embeddings

Word Embeddings:
Capture properties and relationships of individual words. Word2vec was the most well-known embedding model for a long time, accepting only single words but very good at representing semantic meaning, typically outputting 300-dimensional vectors.

Sentence Embeddings:
Associate every sentence with a vector of numbers, capturing meaning at the sentence level rather than individual words.

Document Embeddings:
Represent entire paragraphs or documents as single vectors, useful for document similarity and classification tasks.

Semantic Similarity: The Core Principle

Embeddings that are numerically similar are also semantically similar. This is the fundamental principle that makes embeddings powerful.

Similar words, documents, or images have vectors that are also similar. For example, "basketball" and "baseball" have embedding vectors much closer to each other than "rainforest".

Measuring Similarity:

The most popular way to compare vectors is cosine similarity, which measures the cosine of the angle between two vectors in multi-dimensional space. The closer the vectors, the smaller the angle.

Other Distance Metrics:

Euclidean distance: Straight-line distance between vectors
Dot product (inner product): Especially effective for unit vectors
Manhattan distance: Sum of absolute differences

Cosine similarity is popular for text embeddings, measuring the angle between vectors. Dot product can also work, especially for unit vectors, offering performance benefits in vector databases.

Embedding Model Evolution

Word2vec was the pioneer, focusing on single words with 300 dimensions—lightweight and great for semantic meaning. Then came OpenAI's text-embedding-ada-002 in 2022, supporting up to 8192 tokens and outputting 1536 dimensions.

2025 State of the Art:

Advances in 2025, driven by LLMs and benchmarks, show transformer-based and instruction-tuned embeddings achieving top performance. Key trends include multilingual models (1000+ languages), domain-specific models (medicine, code), and multimodal models (text-image-audio).

Embedding Use Cases

1. Vector Databases and Semantic Search

The most common use case: Embeddings are mostly used for semantic searches where the search function focuses on the meaning of the text rather than finding results based on keywords.

Workflow:

User query is converted to a vector representation using an embedding model
Query vector is stored/compared in a vector database
Similar vectors are retrieved from private content
Retrieved content is sent to an LLM for response generation
LLM sends response back to the user

We use the embedding model to create vector embeddings for content we want to index. The vector embedding is inserted into the vector database with some reference to the original content.

2. Recommendation Systems

By embedding items (products, articles, movies) and user preferences, systems can recommend semantically similar items even if they don't share obvious keywords.

3. Text Classification and Clustering

Embeddings enable text classification and text clustering by grouping semantically similar items together.

Applications:

Classifying support tickets by department
Categorizing documents by topic
Detecting duplicate or similar content
Sentiment analysis grouping

4. Retrieval-Augmented Generation (RAG)

While the most common scenario for vector databases is retrieval-augmented generation (RAG), other possible use cases include recommendations, anomaly detection, and more.

5. Question Answering Systems

Create chatbots that respond to questions about your own data—for instance, a chatbot responding to employee questions on healthcare coverage. Hundreds of pages of documentation can be split into chunks, converted into embeddings, and searched based on vector similarity.

6. Semantic Caching

Reduce cost and latency of LLMs by caching LLM completions. LLM queries are compared using vector similarity—if a new query is similar enough to a previously cached query, the cached query is returned.

7. LLM Conversation Memory

Persist conversation history with an LLM as embeddings in a vector database. Applications can use vector search to pull relevant history or "memories" into LLM responses.

8. Cross-Lingual and Multimodal Search

We can use vector search across languages since embedding models are frequently trained on more than just English data, and we can use vector search with images if we use multimodal embedding models trained on both text and images.

Vector Databases: Storage and Retrieval

A vector database is a database that can store, manage, retrieve, and compare vectors.

Key Capabilities:

Vector databases are purpose-built to manage vector embeddings, offering data management (insert, delete, update), metadata storage and filtering, scalability with distributed processing, and real-time query performance.

Popular Vector Databases:

Pinecone
Weaviate
Qdrant
Milvus
Chroma
Oracle Database 23ai (with AI Vector Search)
Azure Redis
MyScale

Advanced Features:

Some vector databases can perform hybrid searches by first narrowing results based on characteristics or metadata before conducting vector search—making searches more effective and customizable.

OCI Embedding Model Input Requirements

Input data for text embeddings must meet the following requirements: maximum of 96 inputs allowed for each run, with each input less than 512 tokens for text-only models.

Handling Long Inputs:

If an input exceeds the 512 token limit, you can set the Truncate parameter to Start or End to cut off text to fit within the token limit. Setting it to None will produce an error if inputs exceed limits.

Multimodal Support:

For text and image embed models like Cohere Embed English Image V3, you can add either text or one image only.

Best Practices for OCI Generative AI

Chat Model Optimization

Start Simple: Begin with default parameters, then adjust based on results
Temperature First: Adjust temperature before other sampling parameters
Use Preambles Wisely: Set clear behavioral expectations with custom preambles
Implement Stop Sequences: Control output format and length precisely
Test Reproducibility: Use seed parameter during development for consistent testing
Monitor Penalties: Add frequency/presence penalties if seeing repetition

Embedding Model Selection

Choose Appropriate Dimensions: Use light models (384d) for most applications; standard models (1024d) for complex similarity tasks
Select Right Model: English vs. Multilingual based on your data
Batch Process: Take advantage of the 96-input limit for efficient processing
Index Strategically: Store embeddings in vector databases with appropriate indexes
Measure Appropriately: Use cosine similarity for most text applications

Integration Patterns

OCI Generative AI integrates with LangChain for building context-augmented applications and RAG solutions. It also works with LlamaIndex for accessing pretrained models or creating custom models on dedicated AI clusters.

Understanding chat and embedding models in OCI Generative AI enables you to build sophisticated AI applications. Chat models with properly tuned parameters (temperature, top-k, top-p, penalties) produce high-quality, contextually appropriate responses. Embedding models convert text into semantic vectors that power search, recommendations, and retrieval systems.

Key takeaways:

Tokens are the fundamental unit—everything is measured in tokens, not characters
Temperature controls creativity—low for precision, high for creativity
Sampling parameters work together—Top-K and Top-P filter candidates before temperature applies
Embeddings enable semantic understanding—similar meanings produce similar vectors
Vector databases make it practical—efficient storage and retrieval of embeddings at scale

Whether building chatbots, implementing semantic search, or creating RAG applications, mastering these parameters and concepts is essential for production-grade AI systems on OCI.