Pixeltable

https://docs.pixeltable.com/docs/
Admin
Pixeltable is a multimodal data platform that enables building and managing AI applications with...
Tokens:7,270
Snippets:30
Trust Score:6.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Pixeltable Python Package

Source: https://context7.com/context7/pixeltable/llms.txt

Installs the Pixeltable library using pip. Supports installation with specific integrations (e.g., OpenAI, Anthropic, Hugging Face) or all extras.

```bash
pip install pixeltable

pip install pixeltable[openai]
pip install pixeltable[anthropic]
pip install pixeltable[huggingface]

pip install pixeltable[all]
```

--------------------------------

### Implement a Complete RAG Pipeline with Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This comprehensive example outlines the steps to build a RAG (Retrieval-Augmented Generation) pipeline using Pixeltable. It includes creating a documents table, extracting and chunking text from documents, generating embeddings for the chunks, setting up a vector index, and defining a query function that retrieves relevant context and generates an answer using an LLM.

```python
import pixeltable as pxt

# 1. Create documents table
docs = pxt.create_table('rag.documents', schema={
    'doc_id': pxt.String,
    'document': pxt.Document,
    'source': pxt.String
})

# 2. Extract and chunk text
docs.add_column(text=pxt.functions.document.extract_text(docs.document))
docs.add_column(chunks=pxt.functions.text.chunk(docs.text, chunk_size=512, overlap=50))

# 3. Create chunks view
chunks = pxt.create_view(
    'rag.chunks',
    docs.select(docs.doc_id, docs.source, docs.chunks).explode(docs.chunks)
)

# 4. Generate embeddings
chunks.add_column(
    embedding=pxt.functions.openai.embeddings(
        text=chunks.chunks,
        model='text-embedding-3-small'
    )['data'][0]['embedding']
)

# 5. Add vector index
chunks.add_index('embedding_idx', chunks.embedding)

# 6. Query function
def query_rag(question: str, top_k: int = 5):
    # Get question embedding
    q_emb_response = pxt.functions.openai.embeddings(
        text=question,
        model='text-embedding-3-small'
    )
    q_embedding = q_emb_response['data'][0]['embedding']

    # Find similar chunks
    results = chunks.select(
        chunks.chunks,
        chunks.source,
        similarity=chunks.embedding.similarity(q_embedding)
    ).order_by(similarity, ascending=False).limit(top_k).collect()

    # Build context
    context = '\n\n'.join([f"Source: {r['source']}\n{r['chunks']}" for r in results])

    # Generate answer
    response = pxt.functions.openai.chat_completions(
        messages=[
            {'role': 'system', 'content': 'Answer questions based on the provided context.'},
            {'role': 'user', 'content': f'Context:\n{context}\n\nQuestion: {question}'}
        ],
        model='gpt-4',
        temperature=0.3
    )

    return {
        'answer': response['choices'][0]['message']['content'],
        'sources': [r['source'] for r in results]
    }
```

--------------------------------

### Create Derived Tables with Filtering and Transformations in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This example shows how to create derived views ('premium_products', 'enriched_view') from existing tables in Pixeltable. It includes filtering data based on conditions (e.g., price > 1000) and transforming data by selecting specific columns. It also demonstrates querying these views and how views automatically update upon base table changes.

```python
# Create view with filtered data
premium_products = pxt.create_view(
    'project.premium',
    table.select(table.name, table.price, table.description)
    .where(table.price > 1000)
)

# Create view with transformations
enriched_view = pxt.create_view(
    'project.enriched',
    table.select(
        table.name,
        table.price,
        table.ai_description,
        table.embedding_vector
    )
)

# Query view like a table
results = premium_products.select(
    premium_products.name,
    premium_products.price
).order_by(premium_products.price, ascending=False).collect()

# Views automatically update when base table changes
table.insert([{'name': 'New Premium Item', 'price': 2000}])
# premium_products view now includes the new item
```

--------------------------------

### Filter Data by Timestamp Range in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates filtering records in a Pixeltable based on a timestamp range. This example selects records created within the last seven days, showcasing time-based querying capabilities.

```python
from datetime import timedelta

recent = advanced_table.select(
    advanced_table.id,
    advanced_table.timestamp
).where(advanced_table.timestamp > datetime.now() - timedelta(days=7)).collect()
```

--------------------------------

### Add Computed Column with UDF in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates adding a computed column to a Pixeltable using a User-Defined Function (UDF). Includes examples of a simple formatting UDF and a UDF with error handling.

```python
import pixeltable as pxt

# Define a user-defined function
@pxt.udf
def format_price(price: float) -> str:
    return f"${price:.2f}"

# Add computed column
table.add_column(formatted_price=format_price(table.price))

# Query computed column
results = table.select(table.name, table.formatted_price).collect()
# Returns: [{'name': 'Laptop', 'formatted_price': '$1299.99'}, ...]

# Complex UDF with error handling
@pxt.udf(return_type=pxt.String)
def safe_process(text: str) -> str:
    try:
        result = text.upper().strip()
        return result
    except Exception as e:
        return f"ERROR: {str(e)}"

table.add_column(processed=safe_process(table.description))
```

--------------------------------

### Basic RAG Usage with Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates basic usage of Pixeltable for document insertion and querying using a RAG (Retrieval Augmented Generation) approach. It shows how to insert documents and then query for information, printing the answer and its sources.

```python
docs.insert([
    {'doc_id': 'd1', 'document': '/path/to/manual.pdf', 'source': 'Product Manual'},
    {'doc_id': 'd2', 'document': '/path/to/guide.pdf', 'source': 'User Guide'}
])

result = query_rag('How do I reset the device?')
print(result['answer'])
print(f"Sources: {', '.join(result['sources'])}")
```

--------------------------------

### OpenAI Integration for Chat Completions in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Shows how to integrate Pixeltable with OpenAI's Chat Completions API to generate AI-powered content, such as product descriptions, and add it as a new column.

```python
# Add AI-generated product descriptions
table.add_column(
    ai_description=pxt.functions.openai.chat_completions(
        messages=[
            {'role': 'system', 'content': 'You are a product copywriter.'},
            {'role': 'user', 'content': f'Write a compelling description for: {table.name}'}
        ],
        model='gpt-4',
        temperature=0.7,
        max_tokens=200
    )
)

# Query results
results = table.select(table.name, table.ai_description).collect()
# Each row now has an AI-generated description
```

--------------------------------

### Create and Insert Data into Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates creating a Pixeltable with a multimodal schema (including String, Image, Video, Float, Json) and inserting data into it.

```python
import pixeltable as pxt

# Create a table with multimodal schema
table = pxt.create_table('project.products', schema={
    'product_id': pxt.String,
    'name': pxt.String,
    'description': pxt.String,
    'image': pxt.Image,
    'video': pxt.Video,
    'price': pxt.Float,
    'metadata': pxt.Json
})

# Insert data
table.insert([
    {
        'product_id': 'p001',
        'name': 'Laptop',
        'description': 'High-performance laptop',
        'image': '/path/to/laptop.jpg',
        'price': 1299.99,
        'metadata': {'brand': 'TechCo', 'warranty': '2 years'}
    },
    {
        'product_id': 'p002',
        'name': 'Headphones',
        'description': 'Noise-canceling headphones',
        'image': '/path/to/headphones.jpg',
        'video': '/path/to/demo.mp4',
        'price': 299.99,
        'metadata': {'brand': 'AudioPro', 'wireless': True}
    }
])
```

--------------------------------

### Manage Table Snapshots and Versioning in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This code demonstrates how to use Pixeltable's snapshot feature for version control of tables. It covers creating snapshots at different stages, making modifications to the table (insertions, updates), restoring a table to a previous snapshot, and comparing different versions to see changes.

```python
# Create a snapshot for reproducibility
snapshot_v1 = table.create_snapshot('v1.0')

# Make changes to the table
table.insert([{'name': 'New Product', 'price': 499.99}])
table.update({'price': 1099.99}, where=table.name == 'Laptop')

# Create another snapshot
snapshot_v2 = table.create_snapshot('v2.0')

# Restore to previous version
table.restore_snapshot('v1.0')

# Compare versions
diff = table.diff(snapshot_v1)
# Shows: insertions, deletions, and updates between versions

# Query specific snapshot without restoring
results = snapshot_v1.select(snapshot_v1.name, snapshot_v1.price).collect()
```

--------------------------------

### OpenAI Vision - Analyze Product Images

Source: https://context7.com/context7/pixeltable/llms.txt

Utilizes OpenAI's Vision models to analyze product images, providing detailed descriptions and generating SEO-friendly captions. The output can be queried to retrieve product names along with their analysis and captions.

```python
# Analyze product images
table.add_column(
    image_analysis=pxt.functions.openai.vision(
        image=table.image,
        prompt='Describe this product in detail, including colors, materials, and key features.',
        model='gpt-4-vision-preview',
        max_tokens=300
    )
)

# Generate image captions
table.add_column(
    caption=pxt.functions.openai.vision(
        image=table.image,
        prompt='Generate a short, SEO-friendly caption for this product image.',
        model='gpt-4-vision-preview'
    )
)

# Query results
results = table.select(
    table.name,
    table.image_analysis,
    table.caption
).collect()
```

--------------------------------

### Vector Index - Create and Search Similarity Indexes

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates the creation of vector indexes for efficient similarity searches. It covers creating an index on embedding vectors, performing similarity searches, and the ability to create multiple indexes for different data types.

```python
# Create vector index for fast similarity search
table.add_index('embedding_idx', table.embedding_vector, metric='cosine')

# Perform similarity search with index
query_embedding = get_query_embedding('laptop computer')

results = table.select(
    table.name,
    table.description,
    table.price,
    similarity=table.embedding_vector.similarity(query_embedding)
).order_by(similarity, ascending=False).limit(5).collect()

# Multiple indexes for different embedding types
table.add_index('text_idx', table.embedding_vector, metric='cosine')
table.add_index('image_idx', table.image_embedding, metric='euclidean')
```

--------------------------------

### Configure API Keys for Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Configures API keys for AI providers like OpenAI and Anthropic within Pixeltable. Alternatively, API keys can be set using environment variables.

```python
import pixeltable as pxt

pxt.configure_openai(api_key='sk-proj-...')
pxt.configure_anthropic(api_key='sk-ant-...')

# Alternatively, use environment variables:
# export OPENAI_API_KEY=sk-proj-...
# export ANTHROPIC_API_KEY=sk-ant-...
```

--------------------------------

### Create and Analyze Video Frames with AI using Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This snippet demonstrates how to create a view from video data, extract individual frames, analyze them using an AI model (OpenAI Vision) to generate descriptions, and then query these frames based on their content. It involves video processing and AI-driven data enrichment.

```python
frames_view = pxt.create_view(
    'media.frames',
    videos.select(videos.video_id, videos.title, videos.frames).explode(videos.frames)
)

frames_view.add_column(
    frame_description=pxt.functions.openai.vision(
        image=frames_view.frames,
        prompt='Describe what is happening in this video frame.'
    )
)

results = frames_view.select(
    frames_view.video_id,
    frames_view.frame_description
).where(frames_view.frame_description.contains('person')).collect()
```

--------------------------------

### Query Data in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Shows how to query data from a Pixeltable, including selecting specific columns, filtering with a WHERE clause, sorting results, and iterating over large result sets using batches.

```python
# Select specific columns
results = table.select(table.name, table.price).collect()
# Returns: [{'name': 'Laptop', 'price': 1299.99}, {'name': 'Headphones', 'price': 299.99}]

# Filter with where clause
expensive = table.select(
    table.name,
    table.price
).where(table.price > 500).collect()
# Returns: [{'name': 'Laptop', 'price': 1299.99}]

# Sort results
sorted_results = table.select(
    table.name,
    table.price
).order_by(table.price, ascending=False).limit(5).collect()

# Iterate over large result sets
for batch in table.select(table.name).iter_batches(batch_size=100):
    process_batch(batch)
```

--------------------------------

### Multimodal Product Enrichment Pipeline with Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This pipeline uses Pixeltable to enrich a product catalog by generating AI descriptions from images, creating SEO-optimized titles, and generating embeddings for text and image search. It includes functions for both text and image similarity search.

```python
import pixeltable as pxt

# Create product catalog
products = pxt.create_table('catalog.products', schema={
    'sku': pxt.String,
    'image': pxt.Image,
    'basic_name': pxt.String
})

# Generate AI descriptions from images
products.add_column(
    ai_description=pxt.functions.openai.vision(
        image=products.image,
        prompt='Describe this product comprehensively for an e-commerce listing. Include style, materials, and use cases.',
        model='gpt-4-vision-preview',
        max_tokens=300
    )
)

# Generate SEO-optimized titles
products.add_column(
    seo_title=pxt.functions.anthropic.messages(
        messages=[{
            'role': 'user',
            'content': f'Create an SEO-optimized product title based on: {products.ai_description}'
        }],
        model='claude-3-5-sonnet-20241022',
        max_tokens=100
    )['content'][0]['text']
)

# Generate embeddings for text and image search
products.add_column(
    text_embedding=pxt.functions.openai.embeddings(
        text=products.ai_description,
        model='text-embedding-3-small'
    )['data'][0]['embedding']
)

products.add_column(
    image_embedding=pxt.functions.clip.embed_image(products.image)
)

# Add indexes
products.add_index('text_idx', products.text_embedding)
products.add_index('image_idx', products.image_embedding)

# Semantic text search
def search_by_text(query: str, limit: int = 10):
    q_emb = pxt.functions.openai.embeddings(
        text=query,
        model='text-embedding-3-small'
    )['data'][0]['embedding']

    return products.select(
        products.sku,
        products.seo_title,
        products.ai_description,
        similarity=products.text_embedding.similarity(q_emb)
    ).order_by(similarity, ascending=False).limit(limit).collect()

# Visual similarity search
def search_by_image(image_path: str, limit: int = 10):
    q_emb = pxt.functions.clip.embed_image(image_path)

    return products.select(
        products.sku,
        products.seo_title,
        similarity=products.image_embedding.similarity(q_emb)
    ).order_by(similarity, ascending=False).limit(limit).collect()

# Usage
products.insert([
    {'sku': 'P001', 'image': '/path/to/shoe.jpg', 'basic_name': 'Shoe'},
    {'sku': 'P002', 'image': '/path/to/bag.jpg', 'basic_name': 'Bag'}
])

text_results = search_by_text('stylish leather accessories')
image_results = search_by_image('/path/to/similar-item.jpg')
```

--------------------------------

### Video Content Analysis Pipeline with Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This pipeline enables analysis of video content by creating a video table, extracting frames, analyzing each frame for scene descriptions using AI, generating embeddings for semantic search, and indexing the embeddings. It includes a function to search for video moments based on a text query.

```python
import pixeltable as pxt

# 1. Create video table
videos = pxt.create_table('analysis.videos', schema={
    'video_id': pxt.String,
    'video': pxt.Video,
    'title': pxt.String,
    'category': pxt.String
})

# 2. Extract frames (2 per second)
videos.add_column(
    frames=pxt.functions.video.extract_frames(videos.video, fps=2)
)

# 3. Create frames view
frames_view = pxt.create_view(
    'analysis.frames',
    videos.select(
        videos.video_id,
        videos.title,
        videos.category,
        videos.frames
    ).explode(videos.frames)
)

# 4. Analyze each frame
frames_view.add_column(
    scene_description=pxt.functions.openai.vision(
        image=frames_view.frames,
        prompt='Describe the scene, objects, and activities in this video frame.',
        model='gpt-4-vision-preview'
    )
)

# 5. Generate embeddings for semantic search
frames_view.add_column(
    embedding=pxt.functions.openai.embeddings(
        text=frames_view.scene_description,
        model='text-embedding-3-small'
    )['data'][0]['embedding']
)

# 6. Add index
frames_view.add_index('scene_idx', frames_view.embedding)

# 7. Search function
def search_video_moments(query: str, category: str = None, limit: int = 20):
    q_emb = pxt.functions.openai.embeddings(
        text=query,
        model='text-embedding-3-small'
    )['data'][0]['embedding']

    results_query = frames_view.select(
        frames_view.video_id,
        frames_view.title,
        frames_view.scene_description,
        similarity=frames_view.embedding.similarity(q_emb)
    )

    if category:
        results_query = results_query.where(frames_view.category == category)

    return results_query.order_by(similarity, ascending=False).limit(limit).collect()
```

--------------------------------

### Video Processing - Extract Frames

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates how to process video data by extracting frames at specified rates. This includes creating a video table and using functions to extract frames at 1 frame per second or at 5-second intervals.

```python
# Create video table
videos = pxt.create_table('media.videos', schema={
    'video_id': pxt.String,
    'video': pxt.Video,
    'title': pxt.String
})

# Extract frames at 1 fps
videos.add_column(
    frames=pxt.functions.video.extract_frames(
        videos.video,
        fps=1
    )
)

# Extract frames at specific intervals (every 5 seconds)
videos.add_column(
    keyframes=pxt.functions.video.extract_frames(
        videos.video,
        fps=0.2  # 1 frame every 5 seconds
    )
)
```

--------------------------------

### Anthropic Claude - Content Generation and Review Extraction

Source: https://context7.com/context7/pixeltable/llms.txt

Integrates with Anthropic's Claude models to generate content, such as customer reviews, based on product information. It demonstrates how to extract the generated review text for further use and query results.

```python
# Use Claude for content generation
table.add_column(
    claude_review=pxt.functions.anthropic.messages(
        messages=[
            {
                'role': 'user',
                'content': f'Write a customer review for this product: {table.name}. Description: {table.description}'
            }
        ],
        model='claude-3-5-sonnet-20241022',
        max_tokens=500,
        temperature=0.8
    )
)

# Extract response content
table.add_column(
    review_text=table.claude_review['content'][0]['text']
)

# Query results
results = table.select(table.name, table.review_text).collect()
```

--------------------------------

### Image Processing - Resize and Embed Images

Source: https://context7.com/context7/pixeltable/llms.txt

Provides functions for image processing, including resizing images to specified dimensions and generating CLIP embeddings for visual similarity searches. It also shows how to create an image index and perform visual similarity searches.

```python
# Resize images
table.add_column(
    thumbnail=pxt.functions.image.resize(
        table.image,
        width=224,
        height=224
    )
)

# Generate CLIP embeddings for image similarity
table.add_column(
    image_embedding=pxt.functions.clip.embed_image(
        table.image
    )
)

# Create image index
table.add_index('img_idx', table.image_embedding)

# Visual similarity search
query_image = '/path/to/query.jpg'
query_emb = pxt.functions.clip.embed_image(query_image)

similar_images = table.select(
    table.name,
    table.image,
    similarity=table.image_embedding.similarity(query_emb)
).order_by(similarity, ascending=False).limit(10).collect()
```

--------------------------------

### Generate Video Summaries with AI

Source: https://context7.com/context7/pixeltable/llms.txt

This snippet demonstrates how to generate video summaries using an AI model (Anthropic's Claude). It defines a UDF to extract scene descriptions from video frames, combines the first 10 descriptions, and sends them to the AI model for summarization. The summary is then added as a new column to the videos table.

```python
import pixeltable as pxt

@pxt.udf(return_type=pxt.String)
def summarize_video(video_id: str) -> str:
    frame_descriptions = frames_view.select(
        frames_view.scene_description
    ).where(frames_view.video_id == video_id).collect()

    descriptions = [f['scene_description'] for f in frame_descriptions]
    combined = '\n'.join(descriptions[:10])  # First 10 frames

    summary = pxt.functions.anthropic.messages(
        messages=[
            {
                'role': 'user',
                'content': f'Summarize this video based on frame descriptions:\n{combined}'
            }
        ],
        model='claude-3-5-sonnet-20241022',
        max_tokens=200
    )

    return summary['content'][0]['text']

videos.add_column(summary=summarize_video(videos.video_id))

videos.insert([
    {'video_id': 'v001', 'video': '/path/to/tutorial.mp4', 'title': 'Product Tutorial', 'category': 'education'},
    {'video_id': 'v002', 'video': '/path/to/review.mp4', 'title': 'Product Review', 'category': 'review'}
])

moments = search_video_moments('person using smartphone', category='education')
```

--------------------------------

### Process Documents and Create Chunks for RAG with Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

This code illustrates the process of ingesting PDF documents, extracting their text content, and then chunking the text into smaller, manageable pieces suitable for Retrieval-Augmented Generation (RAG). It includes creating embeddings for these chunks and setting up a vector index for efficient semantic search.

```python
# Create document table
docs = pxt.create_table('documents.files', schema={
    'doc_id': pxt.String,
    'pdf_file': pxt.Document,
    'title': pxt.String
})

# Extract text from PDFs
docs.add_column(
    text=pxt.functions.document.extract_text(
        docs.pdf_file
    )
)

# Chunk text for RAG
docs.add_column(
    chunks=pxt.functions.text.chunk(
        docs.text,
        chunk_size=512,
        overlap=50
    )
)

# Create chunks view
chunks_view = pxt.create_view(
    'documents.chunks',
    docs.select(docs.doc_id, docs.title, docs.chunks).explode(docs.chunks)
)

# Generate embeddings for each chunk
chunks_view.add_column(
    chunk_embedding=pxt.functions.openai.embeddings(
        text=chunks_view.chunks,
        model='text-embedding-3-small'
    )['data'][0]['embedding']
)

# Add index for semantic search
chunks_view.add_index('chunk_idx', chunks_view.chunk_embedding)
```

--------------------------------

### Batch Processing with Error Handling using OpenAI

Source: https://context7.com/context7/pixeltable/llms.txt

This snippet shows how to perform batch processing with robust error handling using OpenAI's API. It defines a `safe_api_call` UDF that wraps the API call in a try-except block, returning a JSON object indicating the status ('success' or 'error') and the result or error message. This allows for easy querying of successful and failed operations for retries or further analysis. It also includes batch iteration with monitoring.

```python
import pixeltable as pxt
from typing import Optional

data = pxt.create_table('processing.jobs', schema={
    'job_id': pxt.String,
    'input_text': pxt.String,
    'priority': pxt.Int
})

@pxt.udf(return_type=pxt.Json)
def safe_api_call(text: str) -> dict:
    try:
        response = pxt.functions.openai.chat_completions(
            messages=[{'role': 'user', 'content': text}],
            model='gpt-4',
            max_tokens=500,
            timeout=30
        )
        return {
            'status': 'success',
            'result': response['choices'][0]['message']['content'],
            'error': None
        }
    except Exception as e:
        return {
            'status': 'error',
            'result': None,
            'error': str(e)
        }

data.add_column(result=safe_api_call(data.input_text))

data.add_column(status=data.result['status'])
data.add_column(output=data.result['result'])
data.add_column(error_msg=data.result['error'])

successful = data.select(
    data.job_id,
    data.output
).where(data.status == 'success').collect()

failed = data.select(
    data.job_id,
    data.input_text,
    data.error_msg
).where(data.status == 'error').collect()

batch_size = 100
for i, batch in enumerate(data.select(data.job_id, data.status).iter_batches(batch_size)):
    success_count = sum(1 for item in batch if item['status'] == 'success')
    print(f"Batch {i}: {success_count}/{len(batch)} successful")
```

--------------------------------

### OpenAI Embeddings - Generate and Search Text Embeddings

Source: https://context7.com/context7/pixeltable/llms.txt

Generates text embeddings using OpenAI's models for semantic search and similarity comparisons. It includes generating embedding vectors and performing similarity searches, returning ranked results.

```python
# Generate text embeddings for semantic search
table.add_column(
    embedding=pxt.functions.openai.embeddings(
        text=table.description,
        model='text-embedding-3-small'
    )
)

# Extract embedding vector
table.add_column(
    embedding_vector=table.embedding['data'][0]['embedding']
)

# Perform similarity search
query_text = "wireless audio device"
query_embedding = pxt.functions.openai.embeddings(
    text=query_text,
    model='text-embedding-3-small'
)

results = table.select(
    table.name,
    table.description,
    similarity=table.embedding_vector.similarity(query_embedding['data'][0]['embedding'])
).order_by(similarity, ascending=False).limit(10).collect()
```

--------------------------------

### Update and Delete Data in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Illustrates how to update existing records in a Pixeltable, either single or multiple fields, and how to delete specific records or all records.

```python
# Update specific records
table.update({'price': 1199.99}, where=table.product_id == 'p001')

# Update multiple fields
table.update(
    {'description': 'Premium laptop', 'price': 1399.99},
    where=table.name == 'Laptop'
)

# Delete records
table.delete(where=table.price < 100)

# Delete all records (use with caution)
table.delete()
```

--------------------------------

### Query Data with JSON Navigation in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Illustrates querying data from a Pixeltable using JSON navigation to access nested fields within the 'metadata' column. This allows for precise retrieval of specific attributes from complex data structures.

```python
results = advanced_table.select(
    advanced_table.id,
    advanced_table.metadata['manufacturer'],
    advanced_table.metadata['specs']['ram']
).collect()
```

--------------------------------

### Hugging Face Sentence Transformers - Generate Embeddings

Source: https://context7.com/context7/pixeltable/llms.txt

Generates text embeddings using Hugging Face's Sentence Transformer models. This snippet shows how to use different models for generating embeddings, suitable for various semantic tasks.

```python
# Generate embeddings with Hugging Face models
table.add_column(
    hf_embedding=pxt.functions.huggingface.sentence_transformer(
        text=table.description,
        model='sentence-transformers/all-MiniLM-L6-v2'
    )
)

# Use different models for specific tasks
table.add_column(
    semantic_embedding=pxt.functions.huggingface.sentence_transformer(
        text=table.description,
        model='sentence-transformers/all-mpnet-base-v2'
    )
)
```

--------------------------------

### Custom UDFs with Array, JSON, and Optional Outputs

Source: https://context7.com/context7/pixeltable/llms.txt

This snippet illustrates how to define custom User Defined Functions (UDFs) in Pixeltable with various return types. It includes functions for generating embeddings (returning a float array), analyzing sentiment (returning a JSON object), safely extracting optional data (returning a string), and conditionally processing text based on price (returning a string). Type annotations are used to specify the expected return types.

```python
import pixeltable as pxt
from typing import List, Dict, Optional

@pxt.udf(return_type=pxt.Array[pxt.Float])
def custom_embedding(text: str) -> List[float]:
    from sentence_transformers import SentenceTransformer
    model = SentenceTransformer('all-MiniLM-L6-v2')
    return model.encode(text).tolist()

table.add_column(custom_emb=custom_embedding(table.description))

@pxt.udf(return_type=pxt.Json)
def analyze_sentiment(text: str) -> Dict[str, any]:
    return {
        'sentiment': 'positive',
        'score': 0.85,
        'keywords': ['great', 'excellent', 'amazing']
    }

table.add_column(sentiment=analyze_sentiment(table.description))

@pxt.udf(return_type=pxt.String)
def safe_extract(data: Optional[dict], key: str) -> str:
    if data is None:
        return 'N/A'
    return data.get(key, 'Not found')

table.add_column(extracted=safe_extract(table.metadata, 'brand'))

@pxt.udf(return_type=pxt.String)
def conditional_process(text: str, threshold: float, price: float) -> str:
    if price > threshold:
        return text.upper()
    else:
        return text.lower()

table.add_column(
    processed=conditional_process(table.name, 500.0, table.price)
)
```

--------------------------------

### Create Table with Advanced Data Types

Source: https://context7.com/context7/pixeltable/llms.txt

This snippet demonstrates how to create a Pixeltable table with various advanced data types. It includes String, Timestamp, Array of Strings, JSON, Boolean, Audio, and Array of Floats (embedding). This allows for storing and querying complex data structures within Pixeltable.

```python
import pixeltable as pxt
from datetime import datetime

advanced_table = pxt.create_table('project.advanced', schema={
    'id': pxt.String,
    'timestamp': pxt.Timestamp,
    'tags': pxt.Array[pxt.String],
    'metadata': pxt.Json,
    'is_active': pxt.Bool,
    'audio': pxt.Audio,
    'embedding': pxt.Array[pxt.Float]
})
```

--------------------------------

### Insert Data with Advanced Types in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Demonstrates how to insert records into a Pixeltable with complex data types such as datetimes, arrays, nested dictionaries, booleans, file paths, and embeddings. This showcases Pixeltable's ability to handle structured and unstructured data within a single table.

```python
from datetime import datetime

advanced_table.insert([
    {
        'id': 'a001',
        'timestamp': datetime.now(),
        'tags': ['electronics', 'featured', 'sale'],
        'metadata': {
            'manufacturer': 'TechCo',
            'specs': {'ram': '16GB', 'storage': '512GB'},
            'ratings': [4.5, 4.8, 4.6]
        },
        'is_active': True,
        'audio': '/path/to/demo.mp3',
        'embedding': [0.1, 0.2, 0.3, 0.4]
    }
])
```

--------------------------------

### Filter Data by Array Membership in Pixeltable

Source: https://context7.com/context7/pixeltable/llms.txt

Shows how to filter records in a Pixeltable based on whether a specific value exists within an array column ('tags'). This is useful for segmenting data based on categorical tags or keywords.

```python
electronics = advanced_table.select(
    advanced_table.id
).where(advanced_table.tags.contains('electronics')).collect()
```
Tokens:
Raw