Correct Multimodal AI CodeOn the First Try

An open-source Agent Skill that equips AI coding assistants with correct patterns, anti-patterns, and production recipes for building multimodal AI applications with Pixeltable: declarative tables that replace LangChain + pandas + vector databases with one system.

Get the Skill Agent Skills Spec

Get Started in Seconds

Works with any tool that supports the Agent Skills specification, including Cursor, Claude Code, Windsurf, Cline, Codex CLI, and 40+ more.

Any agent (Cursor, Claude Code, Windsurf, Cline, Codex CLI, …)

npx skills add pixeltable/pixeltable-skill

Claude Code plugin: add the marketplace

/plugin marketplace add pixeltable/pixeltable-skill

Claude Code plugin: install

/plugin install pixeltable@pixeltable-skill

Manual (shell script)

curl -fsSL https://raw.githubusercontent.com/pixeltable/pixeltable-skill/main/install.sh | bash -s -- --platform claude-code

Open in your agent

Cursor Claude ChatGPT

Reading this as an agent? Start at /get-started.md

Compatible with

CursorClaude CodeCodex CLIWindsurfClineOpenCodeGemini+ 40 more

Why This Skill Exists

Pixeltable's declarative model is off-distribution from the imperative Python patterns that dominate LLM training data. Without guidance, agents consistently:

✗Import LangChain

✓document_splitter + add_embedding_index

✗Use pandas as the store

✓Pixeltable tables persist & version automatically

✗Write for-loops calling AI

✓Computed columns handle batching & retry

✗Install Pinecone or Chroma

✓Embedding indexes live inside tables

✗Write while-loops for agents

✓Agents are tables where insert triggers the chain

The skill explicitly deflects these priors with bold negative prompts at the top of the file, before providing the correct patterns. This “say what NOT to do first” approach consistently improves first-shot code quality for off-distribution frameworks.

What the Skill Provides

Anti-pattern deflection, core API patterns, agent recipes, and production-ready code, loaded progressively to keep your context lean.

Anti-Pattern Deflection

Five macro negative prompts override training-distribution biases. 15 detailed anti-patterns with wrong/right code examples. 7 hallucinated API warnings with correct alternatives.

# STOP: Do NOT use LangChain, pandas-as-store,
# for-loops calling AI, separate vector DBs,
# or while-loop agents.
#
# Pixeltable replaces all of them with
# declarative tables + computed columns.

5 macro deflections15 anti-patterns7 hallucination guards

Core Patterns

Tables with multimodal types, computed columns for declarative AI pipelines, views with iterators for chunking and frame extraction, embedding indexes for one-liner vector search.

class Docs(TableModel, name='docs'):
    document: pxt.Document

class Chunks(
    TableModel, name='chunks', base=Docs,
    iterator=document_splitter(
        Docs.document, separators='sentence'
    ),
):
    __indexes__ = [
        pxt.EmbeddingIndex(text, embedding=embed_fn)
    ]

Multimodal typesComputed columnsViews & iteratorsEmbedding indexes

Agent & Tool Patterns

Tool-calling pipelines with pxt.tools() + invoke_tools() for OpenAI, Anthropic, Gemini, Groq, and Bedrock. Persistent memory with semantic retrieval. MCP integration.

tools = pxt.tools(get_weather, search_docs)
agent.add_computed_column(
    response=chat_completions(
        messages=msgs, tools=tools
    )
)
agent.add_computed_column(
    result=invoke_tools(agent.response)
)

Tool callingPersistent memoryMCP integration6 agentic patterns

Production Patterns

FastAPIRouter for declarative endpoint generation. Error handling with recompute_columns(). Import/export for CSV, Parquet, Hugging Face, PyTorch. Data sharing via Pixeltable Cloud.

ingest = FastAPIRouter(name='ingest')
ingest.add_insert_route(
    Docs, path='/ingest', inputs=[Docs.document]
)
ingest.bind('my_app')
app.include_router(ingest)

t.recompute_columns('summary', errors_only=True)

FastAPIRouterError retryImport/exportData sharing

See It in Action

Ask your agent to build Pixeltable workflows. It writes correct, production-ready code on the first try.

pixeltable_workflow.py

1import pixeltable as pxt
2from pixeltable.functions.document import document_splitter
3from pixeltable.functions.huggingface import sentence_transformer
4from pixeltable.functions.openai import chat_completions
5
6pxt.create_dir('rag', if_exists='ignore')
7docs = pxt.create_table('rag.docs', {
8    'document': pxt.Document,
9}, if_exists='ignore')
10
11chunks = pxt.create_view('rag.chunks', docs,
12    iterator=document_splitter(
13        document=docs.document,
14        separators='sentence,token_limit', limit=300
15    )
16)
17
18chunks.add_embedding_index('text',
19    string_embed=sentence_transformer.using(
20        model_id='all-MiniLM-L6-v2'
21    )
22)
23
24@pxt.query
25def answer(question: str):
26    sim = chunks.text.similarity(string=question)
27    ctx = chunks.order_by(sim, asc=False).limit(5)
28    return ctx.select(chunks.text, sim)

25+ AI ProvidersCorrect Signatures Built In

Your agent knows the exact function signatures for every supported provider. Just describe what you want. It writes the correct integration code.

Provider	Functions
OpenAI	`chat_completions, embeddings, image_generations, speech, transcriptions`
Anthropic	`messages, invoke_tools`
Google Gemini	`generate_content, invoke_tools`
Hugging Face	`clip, sentence_transformer, detr_for_object_detection`
Together AI	`chat_completions, embeddings, image_generations`
Fireworks	`chat_completions, embeddings`
Ollama	`chat_completions, embeddings`
Mistral	`chat_completions, embeddings`
Groq	`chat_completions, invoke_tools`
AWS Bedrock	`converse, invoke_tools`
+ 15 more	See providers reference →

Progressive Disclosure

The skill loads only what's needed. SKILL.md is the contract. Five reference files load on demand, keeping your agent fast and your context window lean.

Layer	File	Role	Loaded when
Core	`SKILL.md`	contract	Always (on activation)
Reference	`references/core-api.md`	API	Types, views, UDFs, serving
Reference	`references/cli.md`	CLI	pxt schema, pxt service, inspect
Reference	`references/providers.md`	providers	Provider import and output shape
Reference	`references/workflows.md`	HTTP	FastAPIRouter routes and bind()
Reference	`references/anti-patterns.md`	stop	Wrong/right stack

Frequently Asked Questions

Why does Pixeltable need a skill?

Pixeltable's declarative model is off-distribution from the imperative Python patterns that dominate LLM training data. Without guidance, agents consistently import LangChain for chunking, use pandas as a store, write for-loops calling AI models, install Pinecone for embeddings, and write while-loops for agent flows. The skill explicitly deflects these priors with bold negative prompts, then provides the correct declarative patterns.

What are Agent Skills?

Agent Skills are folders of instructions and API references that AI coding agents can discover and use to write accurate code. They follow the open Agent Skills specification (agentskills.io). When you ask your agent about Pixeltable, it automatically loads the skill and writes production-ready code, no guessing about API signatures.

What is the difference between skills and MCP servers?

Skills are static instructions and reference documentation that help agents write better code. MCP servers are live connections that let agents call external APIs at runtime. The Pixeltable skill teaches your agent how to write correct Pixeltable code, while the Pixeltable MCP server lets the agent interact with a running Pixeltable instance. They are complementary.

Which agents and IDEs support skills?

The skill works with any tool that supports the Agent Skills specification, including Cursor, Claude Code, Codex CLI, Windsurf, Cline, OpenCode, Gemini, and 40+ more. Install with npx skills add pixeltable/pixeltable-skill.

How does progressive disclosure work?

The skill uses a two-layer architecture. SKILL.md is the contract (app.py, schema update, service update), loaded every time. Five reference files load on demand: core-api, cli, providers, workflows, and anti-patterns.

What AI providers are covered?

The skill includes integrations for 25+ AI providers: OpenAI, Anthropic, Gemini, Hugging Face, Together, Fireworks, Ollama, Mistral, Groq, DeepSeek, Replicate, Voyage AI, Bedrock, OpenRouter, Twelve Labs, and more. Your agent knows the correct function signatures for all of them.

Do I need Pixeltable Cloud to use the skill?

No. The skill teaches your agent to write Pixeltable code that runs anywhere: locally, in Docker, or on Pixeltable Cloud. Start with pip install 'pixeltable[serve]', pxt init, and pxt service example --out app.py.

Start Buildingin Minutes

Give your AI agent deep Pixeltable expertise. Build multimodal AI applications faster than ever.

Get the Skill Pixeltable Docs

Next Steps

Onboard your agent

Install pxt, the Pixeltable Skill, and MCP

Pixeltable Quick Start

Install and run your first pipeline

Starter Kit

Full-stack template with FastAPI + React

MCP Server

Model Context Protocol for Claude, Cursor, AI IDEs

Skill source on GitHub

Contribute, report issues, or fork

Agent Skills spec

The open standard this skill implements

Discord

Community support and discussion