tessl/pypi-together

Python client for Together's Cloud Platform providing comprehensive AI model APIs

Overview

Eval results

Files

Embeddings

Name: tessl/pypi-together
Author: tessl

Text embedding generation for semantic search, clustering, classification, and similarity analysis. Supports multiple embedding models optimized for different use cases including retrieval, classification, and general-purpose semantic understanding.

Capabilities

Text Embeddings

Generate high-dimensional vector representations of text for semantic processing.

def create(
    model: str,
    input: Union[str, List[str]],
    **kwargs
) -> EmbeddingResponse:
    """
    Create embeddings for input text.

    Args:
        model: Embedding model identifier
        input: Text string or list of strings to embed

    Returns:
        EmbeddingResponse with vector embeddings
    """

Async Embeddings

Asynchronous embedding generation for concurrent processing.

async def create(
    model: str,
    input: Union[str, List[str]],
    **kwargs
) -> EmbeddingResponse:
    """
    Asynchronously create text embeddings.

    Returns:
        EmbeddingResponse with vector embeddings
    """

Usage Examples

Basic Embedding Generation

from together import Together

client = Together()

response = client.embeddings.create(
    model="togethercomputer/m2-bert-80M-8k-retrieval",
    input="Machine learning is transforming technology"
)

embedding = response.data[0].embedding
print(f"Embedding dimension: {len(embedding)}")
print(f"First 5 values: {embedding[:5]}")

Batch Embedding Processing

texts = [
    "Artificial intelligence and machine learning",
    "Deep learning neural networks",
    "Natural language processing",
    "Computer vision applications",
    "Reinforcement learning algorithms"
]

response = client.embeddings.create(
    model="togethercomputer/m2-bert-80M-8k-retrieval",
    input=texts
)

embeddings = [data.embedding for data in response.data]
print(f"Generated {len(embeddings)} embeddings")
print(f"Each embedding has {len(embeddings[0])} dimensions")

Semantic Similarity

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

def calculate_similarity(text1: str, text2: str, model: str) -> float:
    response = client.embeddings.create(
        model=model,
        input=[text1, text2]
    )
    
    embeddings = [data.embedding for data in response.data]
    similarity = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
    return similarity

similarity_score = calculate_similarity(
    "I love programming in Python",
    "Python is my favorite programming language",
    "togethercomputer/m2-bert-80M-8k-retrieval"
)
print(f"Similarity score: {similarity_score:.4f}")

Document Retrieval System

def create_document_embeddings(documents: List[str], model: str) -> List[List[float]]:
    """Create embeddings for a collection of documents."""
    response = client.embeddings.create(model=model, input=documents)
    return [data.embedding for data in response.data]

def find_most_similar(query: str, documents: List[str], model: str, top_k: int = 3):
    """Find most similar documents to a query."""
    # Create embeddings for query and documents
    all_texts = [query] + documents
    response = client.embeddings.create(model=model, input=all_texts)
    embeddings = [data.embedding for data in response.data]
    
    query_embedding = embeddings[0]
    doc_embeddings = embeddings[1:]
    
    # Calculate similarities
    similarities = cosine_similarity([query_embedding], doc_embeddings)[0]
    
    # Get top-k most similar documents
    top_indices = np.argsort(similarities)[::-1][:top_k]
    
    results = []
    for idx in top_indices:
        results.append({
            'document': documents[idx],
            'similarity': similarities[idx],
            'index': idx
        })
    
    return results

# Example usage
documents = [
    "Python is a versatile programming language",
    "Machine learning models require large datasets",
    "Web development with JavaScript frameworks",
    "Database design and optimization techniques",
    "Cloud computing and distributed systems"
]

query = "What programming languages are popular?"
results = find_most_similar(
    query, 
    documents, 
    "togethercomputer/m2-bert-80M-8k-retrieval"
)

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

Async Embedding Processing

import asyncio
from together import AsyncTogether

async def process_embeddings_async():
    client = AsyncTogether()
    
    text_batches = [
        ["AI research and development", "Machine learning applications"],
        ["Data science methodologies", "Statistical analysis techniques"],
        ["Neural network architectures", "Deep learning frameworks"]
    ]
    
    tasks = [
        client.embeddings.create(
            model="togethercomputer/m2-bert-80M-8k-retrieval",
            input=batch
        )
        for batch in text_batches
    ]
    
    responses = await asyncio.gather(*tasks)
    
    all_embeddings = []
    for response in responses:
        batch_embeddings = [data.embedding for data in response.data]
        all_embeddings.extend(batch_embeddings)
    
    print(f"Generated {len(all_embeddings)} embeddings asynchronously")
    return all_embeddings

embeddings = asyncio.run(process_embeddings_async())

Types

Request Types

class EmbeddingRequest:
    model: str
    input: Union[str, List[str]]

Response Types

class EmbeddingResponse:
    object: str
    data: List[EmbeddingData]
    model: str
    usage: EmbeddingUsage

class EmbeddingData:
    object: str
    embedding: List[float]
    index: int

class EmbeddingUsage:
    prompt_tokens: int
    total_tokens: int