omnichat-platform

Parse PDF, DOCX, XLSX, and PPTX documents in a microservices context. Use when building the Media Processor service (Phase 9) for document text extraction. Covers BytesIO streaming, standardized JSON output, async wrappers for CPU-bound operations. NOT for desktop automation, file editing, or document creation.

Design multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality. Includes OpenAI Agents SDK patterns (handoffs, as_tool) required for OmniChat Phase 5. Covers Triage routing, context passing, and streaming specialist patterns.

Generate Redis pub/sub event publisher and subscriber patterns. Use when: (1) Broadcasting events between services, (2) Implementing event-driven patterns, (3) Real-time notifications, (4) Decoupling service communication. Builds on redis-pattern skill with domain-specific event types and handlers. NOT for task queues (use redis-pattern task-queue instead).

Builds AI agents using OpenAI Agents SDK with async/await patterns and multi-agent orchestration. Use when creating tutoring agents, building agent handoffs, implementing tool-calling agents, or orchestrating multiple specialists. Covers Agent class, Runner patterns, function tools, guardrails, and streaming responses. Includes OmniChat distributed patterns: LLM Gateway routing, Persistence bridge, Event Publisher integration, and remote tool stubs. NOT when using raw OpenAI API without SDK or other agent frameworks like LangChain.

Implement backend SSE (Server-Sent Events) infrastructure for real-time AI response streaming. Use when building the Stream Broker service, Redis Pub/Sub listeners, or SSE endpoints. Covers sse-starlette integration, connection management, heartbeats, and event routing. NOT for frontend consumption patterns - this is backend infrastructure only.

Build production RAG systems with semantic chunking, incremental indexing, and filtered retrieval. Use when implementing document ingestion pipelines, vector search with Qdrant, or context-aware retrieval. Covers chunking strategies, change detection, payload indexing, and context expansion. NOT when doing simple similarity search without production requirements.

Production-grade Docker containerization for Python and Node.js applications. This skill should be used when users ask to containerize applications, create Dockerfiles, dockerize projects, or set up Docker Compose. Auto-detects project structure, analyzes .env for secrets, validates security, and generates tested Dockerfiles.

Build production-grade FastAPI backends with SQLModel and JWT authentication. Use when building REST APIs with Neon PostgreSQL, implementing layered architecture (Controller-Service-Repository), or creating CRUD endpoints with JWT/JWKS verification. NOT when building simple scripts or non-microservice architectures.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

Generate adapter pattern for swappable providers in Python async applications. Use when implementing: (1) LLM provider abstraction (OpenAI, Anthropic), (2) Storage adapters (S3, MinIO, local), (3) Search provider abstraction (Tavily, Serper), (4) Sandbox adapters (E2B, Docker). Creates Protocol-based interfaces with async support and proper typing. NOT for simple dependency injection or non-swappable integrations.

Generate Alembic database migrations for SQLModel/SQLAlchemy with async PostgreSQL. Use when: (1) Creating new migration files, (2) Setting up Alembic in a project, (3) Handling schema changes (add/drop columns, tables, indexes), (4) Data migrations, (5) Multi-tenant or multi-database migrations. Generates async-compatible migrations with proper upgrade/downgrade functions. NOT for Django migrations or raw SQL scripts.

Generate GitHub Actions CI/CD workflows for Python FastAPI microservices. Use when: (1) Setting up CI pipelines, (2) Automated testing on PR, (3) Docker image builds, (4) Kubernetes deployments, (5) Release automation. Creates workflows with caching, parallel jobs, and environment-based deployments. NOT for other CI systems (Jenkins, GitLab CI, CircleCI).

Generate integration tests for service-to-service communication. Use when: (1) Testing API endpoints with real database, (2) Testing service interactions, (3) Docker-based test environments, (4) End-to-end workflow validation. Creates pytest fixtures with testcontainers, async database setup, and cleanup. NOT for unit tests (use mock-provider) or load testing.

Generate mock adapters for external services in tests. Use when: (1) Testing code that calls OpenAI/Anthropic, (2) Mocking storage providers, (3) Testing without external dependencies, (4) Simulating error conditions. Creates deterministic mocks with configurable responses and async support. NOT for integration tests with real services.

Generate Redis patterns for Python async applications using redis-py and arq. Use when implementing: (1) Caching with TTL and invalidation, (2) Pub/Sub for real-time events, (3) arq task queues for background jobs, (4) Distributed locks, (5) Rate limiting. Generates production-ready async code with proper connection pooling, error handling, and typing. NOT for Celery, RQ, or synchronous Redis patterns.

Generate typed async httpx clients for inter-service communication. Use when: (1) Calling other microservices, (2) Need retry logic and circuit breakers, (3) Want typed request/response models, (4) Implementing service discovery patterns. Generates async httpx clients with Pydantic models, error handling, and observability. NOT for external API integrations (use adapter-interface instead).