Embedding Models Overview

Transform text into numerical vectors that capture semantic meaning, enabling powerful search, similarity comparison, and classification capabilities.

Available Models

OpenAI Embeddings

text-embedding-3-large: Highest quality embeddings (3,072 dimensions)
text-embedding-3-small: Fast and efficient (1,536 dimensions)
text-embedding-ada-002: Legacy model, still reliable (1,536 dimensions)

Cohere Embeddings

embed-english-v3.0: Optimized for English text
embed-multilingual-v3.0: Support for 100+ languages
embed-english-light-v3.0: Lightweight for speed

Voyage AI

voyage-large-2: High-performance general embeddings
voyage-code-2: Specialized for code embeddings
voyage-law-2: Optimized for legal documents

Google Embeddings

textembedding-gecko: Versatile multilingual embeddings
textembedding-gecko-multilingual: Enhanced multilingual support

Model Capabilities

Semantic Search

Find relevant content based on meaning, not just keywords

Similarity Comparison

Measure semantic similarity between texts

Classification

Categorize content based on embedded features

Clustering

Group similar content automatically

Embeddings API

Convert text to numerical vectors:

POST /v1/embeddings

Basic Example

curl -X POST "https://api.anyapi.ai/v1/embeddings" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-embedding-3-large",
    "input": "The quick brown fox jumps over the lazy dog",
    "encoding_format": "float"
  }'

Response Format

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": [
        -0.006929283495992422,
        -0.005336422007530928,
        0.014362285844981098,
        ...
      ]
    }
  ],
  "model": "text-embedding-3-large",
  "usage": {
    "prompt_tokens": 10,
    "total_tokens": 10
  }
}

Batch Processing

Process multiple texts efficiently:

import requests

texts = [
    "Artificial intelligence is transforming technology",
    "Machine learning enables computers to learn patterns",
    "Deep learning uses neural networks for complex tasks",
    "Natural language processing helps computers understand text"
]

response = requests.post(
    "https://api.anyapi.ai/v1/embeddings",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "model": "text-embedding-3-large",
        "input": texts,
        "encoding_format": "float"
    }
)

embeddings = response.json()["data"]
for i, embedding in enumerate(embeddings):
    print(f"Text {i+1}: {len(embedding['embedding'])} dimensions")

Similarity Search Implementation

Cosine Similarity Calculation

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def calculate_similarity(embedding1, embedding2):
    """Calculate cosine similarity between two embeddings"""
    return cosine_similarity([embedding1], [embedding2])[0][0]

def find_most_similar(query_embedding, document_embeddings, top_k=5):
    """Find most similar documents to query"""
    similarities = []
    
    for i, doc_embedding in enumerate(document_embeddings):
        similarity = calculate_similarity(query_embedding, doc_embedding)
        similarities.append((i, similarity))
    
    # Sort by similarity score
    similarities.sort(key=lambda x: x[1], reverse=True)
    
    return similarities[:top_k]

# Example usage
query = "How does machine learning work?"
documents = [
    "Machine learning algorithms learn from data",
    "Cooking recipes for Italian cuisine",
    "Neural networks are inspired by the brain",
    "Travel guide to Paris France"
]

# Get embeddings for query and documents
query_embedding = get_embedding(query)
doc_embeddings = [get_embedding(doc) for doc in documents]

# Find similar documents
similar_docs = find_most_similar(query_embedding, doc_embeddings)
print("Most similar documents:", similar_docs)

Vector Database Integration

Pinecone Integration

import pinecone
import requests

# Initialize Pinecone
pinecone.init(api_key="your-pinecone-key", environment="us-west1-gcp")
index = pinecone.Index("embeddings-index")

def store_embeddings(texts, metadata_list=None):
    """Store embeddings in Pinecone"""
    # Get embeddings from AnyAPI
    response = requests.post(
        "https://api.anyapi.ai/v1/embeddings",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "text-embedding-3-large",
            "input": texts
        }
    )
    
    embeddings = response.json()["data"]
    
    # Prepare vectors for Pinecone
    vectors = []
    for i, embedding in enumerate(embeddings):
        vector_id = f"doc_{i}"
        metadata = metadata_list[i] if metadata_list else {"text": texts[i]}
        
        vectors.append({
            "id": vector_id,
            "values": embedding["embedding"],
            "metadata": metadata
        })
    
    # Upsert to Pinecone
    index.upsert(vectors)

def search_similar(query, top_k=5):
    """Search for similar documents"""
    # Get query embedding
    response = requests.post(
        "https://api.anyapi.ai/v1/embeddings",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "text-embedding-3-large",
            "input": query
        }
    )
    
    query_embedding = response.json()["data"][0]["embedding"]
    
    # Search in Pinecone
    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True
    )
    
    return results

Weaviate Integration

import weaviate

client = weaviate.Client("http://localhost:8080")

# Create schema
schema = {
    "classes": [{
        "class": "Document",
        "vectorizer": "none",  # We'll provide our own vectors
        "properties": [{
            "name": "content",
            "dataType": ["text"]
        }, {
            "name": "title",
            "dataType": ["string"]
        }]
    }]
}

client.schema.create(schema)

def store_in_weaviate(documents):
    """Store documents with embeddings in Weaviate"""
    for doc in documents:
        # Get embedding from AnyAPI
        response = requests.post(
            "https://api.anyapi.ai/v1/embeddings",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "model": "text-embedding-3-large",
                "input": doc["content"]
            }
        )
        
        embedding = response.json()["data"][0]["embedding"]
        
        # Store in Weaviate
        client.data_object.create(
            data_object=doc,
            class_name="Document",
            vector=embedding
        )

def search_weaviate(query, limit=5):
    """Search documents in Weaviate"""
    # Get query embedding
    response = requests.post(
        "https://api.anyapi.ai/v1/embeddings",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "text-embedding-3-large",
            "input": query
        }
    )
    
    query_embedding = response.json()["data"][0]["embedding"]
    
    # Search in Weaviate
    result = client.query.get("Document", ["content", "title"]) \
        .with_near_vector({"vector": query_embedding}) \
        .with_limit(limit) \
        .do()
    
    return result

Model Comparison

Model	Dimensions	Languages	Strengths	Price/1K tokens
text-embedding-3-large	3,072	English+	Highest quality	$0.00013
text-embedding-3-small	1,536	English+	Speed & efficiency	$0.00002
cohere-embed-v3	1,024	100+	Multilingual	$0.00010
voyage-large-2	1,536	English+	General purpose	$0.00012

Advanced Use Cases

Semantic Search Engine

class SemanticSearchEngine:
    def __init__(self, model="text-embedding-3-large"):
        self.model = model
        self.documents = []
        self.embeddings = []
    
    def add_documents(self, texts):
        """Add documents to search index"""
        response = requests.post(
            "https://api.anyapi.ai/v1/embeddings",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "model": self.model,
                "input": texts
            }
        )
        
        embeddings = response.json()["data"]
        
        for i, text in enumerate(texts):
            self.documents.append(text)
            self.embeddings.append(embeddings[i]["embedding"])
    
    def search(self, query, top_k=5):
        """Search for similar documents"""
        # Get query embedding
        response = requests.post(
            "https://api.anyapi.ai/v1/embeddings",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "model": self.model,
                "input": query
            }
        )
        
        query_embedding = response.json()["data"][0]["embedding"]
        
        # Calculate similarities
        similarities = []
        for i, doc_embedding in enumerate(self.embeddings):
            similarity = cosine_similarity([query_embedding], [doc_embedding])[0][0]
            similarities.append({
                "document": self.documents[i],
                "similarity": similarity,
                "index": i
            })
        
        # Sort and return top results
        similarities.sort(key=lambda x: x["similarity"], reverse=True)
        return similarities[:top_k]

# Usage example
search_engine = SemanticSearchEngine()

documents = [
    "Python is a programming language",
    "Machine learning algorithms learn from data",
    "Cats are popular pets",
    "Neural networks are used in AI",
    "Dogs need regular exercise"
]

search_engine.add_documents(documents)
results = search_engine.search("artificial intelligence", top_k=3)

for result in results:
    print(f"Similarity: {result['similarity']:.3f} - {result['document']}")

Content Classification

class ContentClassifier:
    def __init__(self, categories):
        self.categories = categories
        self.category_embeddings = self._get_category_embeddings()
    
    def _get_category_embeddings(self):
        """Get embeddings for category names"""
        response = requests.post(
            "https://api.anyapi.ai/v1/embeddings",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "model": "text-embedding-3-large",
                "input": list(self.categories.keys())
            }
        )
        
        embeddings = response.json()["data"]
        return {
            category: embeddings[i]["embedding"] 
            for i, category in enumerate(self.categories.keys())
        }
    
    def classify(self, text):
        """Classify text into categories"""
        # Get text embedding
        response = requests.post(
            "https://api.anyapi.ai/v1/embeddings",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json={
                "model": "text-embedding-3-large",
                "input": text
            }
        )
        
        text_embedding = response.json()["data"][0]["embedding"]
        
        # Calculate similarities with categories
        similarities = {}
        for category, category_embedding in self.category_embeddings.items():
            similarity = cosine_similarity([text_embedding], [category_embedding])[0][0]
            similarities[category] = similarity
        
        # Return most similar category
        best_category = max(similarities, key=similarities.get)
        confidence = similarities[best_category]
        
        return {
            "category": best_category,
            "confidence": confidence,
            "all_scores": similarities
        }

# Usage example
categories = {
    "Technology": "Articles about computers, software, and tech innovations",
    "Sports": "News and articles about athletic competitions and games",
    "Politics": "Political news, elections, and government topics",
    "Entertainment": "Movies, music, celebrities, and entertainment news"
}

classifier = ContentClassifier(categories)

text = "The new iPhone features advanced machine learning capabilities"
result = classifier.classify(text)

print(f"Category: {result['category']}")
print(f"Confidence: {result['confidence']:.3f}")

Duplicate Detection

def find_duplicates(texts, threshold=0.95):
    """Find duplicate or near-duplicate texts"""
    # Get embeddings for all texts
    response = requests.post(
        "https://api.anyapi.ai/v1/embeddings",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "text-embedding-3-large",
            "input": texts
        }
    )
    
    embeddings = [data["embedding"] for data in response.json()["data"]]
    
    duplicates = []
    
    for i in range(len(texts)):
        for j in range(i + 1, len(texts)):
            similarity = cosine_similarity([embeddings[i]], [embeddings[j]])[0][0]
            
            if similarity >= threshold:
                duplicates.append({
                    "text1": texts[i],
                    "text2": texts[j],
                    "similarity": similarity,
                    "indices": (i, j)
                })
    
    return duplicates

# Example usage
documents = [
    "The cat sat on the mat",
    "A feline rested on the rug",  # Similar meaning
    "Python is a programming language",
    "The dog ran in the park",
    "The cat sat on the mat"  # Exact duplicate
]

duplicates = find_duplicates(documents, threshold=0.8)
for dup in duplicates:
    print(f"Similarity: {dup['similarity']:.3f}")
    print(f"Text 1: {dup['text1']}")
    print(f"Text 2: {dup['text2']}")
    print("---")

Best Practices

Choosing the Right Model

text-embedding-3-large: Best quality, higher cost
text-embedding-3-small: Good balance of quality and speed
cohere-embed-v3: For multilingual content
voyage-code-2: For code and technical content

Optimization Tips

Batch processing: Send multiple texts in one request
Caching: Store embeddings to avoid recomputation
Preprocessing: Clean and normalize text before embedding
Chunking: Split long documents into smaller segments

Vector Database Selection

Pinecone: Managed, easy to use, great for production
Weaviate: Open source, supports multiple data types
Chroma: Lightweight, good for development
Qdrant: High performance, supports filtering

Rate Limits

Embedding model limits by plan:

Plan	Requests/Min	Tokens/Min	Daily Limit
Free	60	150,000	1M tokens
Pro	3,000	1,000,000	10M tokens
Enterprise	Custom	Custom	Custom

Common Use Cases

Search & Retrieval

Document search, FAQ systems, knowledge bases

Recommendation Systems

Content recommendations, similar item suggestions

Content Moderation

Detect inappropriate content, spam filtering

Data Analysis

Clustering, topic modeling, trend analysis

Integration Examples

RAG (Retrieval-Augmented Generation)

def rag_system(query, knowledge_base):
    """Simple RAG implementation"""
    # 1. Get relevant documents using embeddings
    search_engine = SemanticSearchEngine()
    search_engine.add_documents(knowledge_base)
    relevant_docs = search_engine.search(query, top_k=3)
    
    # 2. Create context from relevant documents
    context = "\n".join([doc["document"] for doc in relevant_docs])
    
    # 3. Generate answer using context
    prompt = f"""
    Context: {context}
    
    Question: {query}
    
    Answer based on the context:
    """
    
    # Call text generation API
    response = requests.post(
        "https://api.anyapi.ai/v1/chat/completions",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "gpt-4o",
            "messages": [{"role": "user", "content": prompt}]
        }
    )
    
    return response.json()["choices"][0]["message"]["content"]

Getting Started

Quick Start

Generate your first embeddings

Use Cases

See practical examples

SDKs

Use our libraries

API Reference

Explore all endpoints

Get started

Features

Use Cases

Developer guides

API Reference

Integrations

​Embedding Models Overview

​Available Models

​OpenAI Embeddings

​Cohere Embeddings

​Voyage AI

​Google Embeddings

​Model Capabilities

Semantic Search

Similarity Comparison

Classification

Clustering

​Embeddings API

​Basic Example

​Response Format

​Batch Processing

​Similarity Search Implementation

​Cosine Similarity Calculation

​Vector Database Integration

​Pinecone Integration

​Weaviate Integration

​Model Comparison

​Advanced Use Cases

​Semantic Search Engine

​Content Classification

​Duplicate Detection

​Best Practices

​Choosing the Right Model

​Optimization Tips

​Vector Database Selection

​Rate Limits

​Common Use Cases

Search & Retrieval

Recommendation Systems

Content Moderation

Data Analysis

​Integration Examples

​RAG (Retrieval-Augmented Generation)

​Getting Started

Quick Start

Use Cases

SDKs

API Reference

Embedding Models Overview

Available Models

OpenAI Embeddings

Cohere Embeddings

Voyage AI

Google Embeddings

Model Capabilities

Embeddings API

Basic Example

Response Format

Batch Processing

Similarity Search Implementation

Cosine Similarity Calculation

Vector Database Integration

Pinecone Integration

Weaviate Integration

Model Comparison

Advanced Use Cases

Semantic Search Engine

Content Classification

Duplicate Detection

Best Practices

Choosing the Right Model

Optimization Tips

Vector Database Selection

Rate Limits

Common Use Cases

Integration Examples

RAG (Retrieval-Augmented Generation)

Getting Started