Vapora/docs/features/overview.md

🎯 Vapora Features

🌟 Development flows
when teams and AI agents orchestrate

Vapora is an intelligent development orchestration platform where teams and AI agents work together in continuous flow. It automates and coordinates software development lifecycle—from design and implementation through testing, documentation, and deployment—while maintaining full context and enabling intelligent decision-making at every step.

Unlike fragmented tool ecosystems, Vapora is a single, self-contained system where developers and AI agents collaborate seamlessly, complexity evaporates, and development flows naturally.

Core Value Proposition

• ✅ Unifies task management with intelligent code context (all in one place)
• ✅ Reduces context switching for developers (no tool jumping)
• ✅ Makes team knowledge discoverable and actionable (searchable, organized)
• ✅ Enables AI agents as first-class team members (12 specialized roles)
• ✅ Self-hosted with cloud-agnostic deployment (own your data)
• ✅ Multi-tenant by design with fine-grained access control (shared platforms)

Target Users

• Development teams needing better coordination and visibility
• Organizations wanting AI assistance embedded in workflow
• Platform engineers managing shared development infrastructure
• Enterprise teams requiring on-premise deployment and data control
• Teams at scale needing fine-grained permissions and multi-tenancy

---

Table of Contents

1. Project Management
2. AI-Powered Intelligence
3. Multi-Agent Coordination
   • Learning-Based Agent Selection (Phase 5.3)
   • Budget Enforcement & Cost Optimization (Phase 5.4)
   • Workflow Orchestrator (v1.2.0)
4. Knowledge Management
5. Cloud-Native & Deployment
6. Security & Multi-Tenancy
7. Technology Stack
8. Optional Integrations

---

Project Management

Kanban Board (Glassmorphism UI)

Solves: Context Switching Infinito

The centerpiece of Vapora is a beautiful, responsive Kanban board with real-time collaboration:

• Intuitive columns: Todo → Doing → Review → Done (customizable)
• Drag & drop task reordering with instant sync across team
• Glassmorphism design with vaporwave aesthetics (modern, beautiful UX)
• Optimistic updates (UI responds instantly, server syncs in background)
• Rich task cards featuring:
  • Title, description, priority levels, tags
  • Assigned team members (developers + AI agents)
  • Subtasks and dependency chains
  • Comments and threaded discussions
  • Time estimates and actual time spent
  • Code snippets and inline documentation

Unified Task Lifecycle

Solves: Task Management Sin Inteligencia

Manage all project work from a single source of truth:

• Work items (tasks, bugs, features, chores)
• Developers + AI agents treated equally as team members
• Task templates for recurring workflow patterns
• Bulk operations (reorder, assign, tag, bulk updates)
• Advanced search & filters:
  • By assignee, status, priority, tags, due date
  • Custom filters (created by, mentioned in, blocked by)
  • Saved search queries
• Multiple views:
  • Kanban view (visual workflow)
  • List view (text-focused)
  • Timeline/Gantt (dependencies and critical path)
  • Calendar view (deadline-focused)
  • Table view (spreadsheet-like)

Real-Time Collaboration

• Live presence (see who's viewing/editing in real-time)
• Collaborative comments with threads and mentions
• Notifications (task assigned, commented, updated, blocked)
• Activity timeline (audit trail of who did what, when)
• @mentions for developers and agents
• Task watchers (subscribe to updates)

Team & Project Organization

• Multiple projects per workspace
• Team members (both humans and AI agents)
• Custom roles with granular permissions
• Team dashboards with metrics and burndown
• Sprint planning (if using Agile workflow)
• Backlog management with story points estimation

---

AI-Powered Intelligence

Intelligent Code Context

Solves: Knowledge Fragmentado, Task Management Sin Inteligencia

Tasks are more than descriptions—they carry full code context:

• Automatic code analysis when tasks reference files or modules
• Code snippets displayed inline with syntax highlighting
• Complexity metrics:
  • Cyclomatic complexity
  • Cognitive complexity
  • Test coverage by module
• Pattern detection:
  • Detect anti-patterns and suggest improvements
  • Identify code duplication
  • Highlight risky changes
• Dependency visualization:
  • Module dependency graphs
  • Impact analysis (what breaks if this changes?)
  • Circular dependency detection
• Architecture insights:
  • Layer violations
  • Service coupling analysis
  • Component relationships

Universal Search with RAG

Solves: Knowledge Fragmentado

Find any information across your entire knowledge base instantly:

• Semantic search powered by RAG (Retrieval-Augmented Generation):

  • Search task descriptions, comments, discussions
  • Find design decisions and ADRs
  • Locate relevant code snippets
  • Find previous solutions to similar problems
  • Natural language queries: "How do we handle user authentication?"

• Local embeddings (fastembed) - privacy-first, no data sent to external services

• Smart ranking:

  • By relevance (semantic similarity)
  • By recency (most recent first)
  • By authority (who wrote it, how many references)

• Context-aware results:

  • Related tasks automatically suggested
  • Similar solutions from past projects
  • Relevant team members who worked on similar issues

AI Agent Capabilities

Every team member is empowered by AI assistance:

• Code-level AI suggestions:

  • Refactoring recommendations
  • Performance optimization hints
  • Test case suggestions
  • Documentation generation

• Task-level automation:

  • Auto-generate task descriptions
  • Suggest related tasks and dependencies
  • Estimate effort based on complexity
  • Recommend assignees based on expertise

• Workflow intelligence:

  • Predict blockers before they happen
  • Suggest task ordering for efficiency
  • Identify bottlenecks in workflow
  • Recommend process improvements

---

Multi-Agent Coordination

Specialized Agents (Customizable & Tunable)

Solves: Task Management Sin Inteligencia, Dev-Ops Handoff Manual, Pipeline Orchestration

Vapora comes with specialized agents that can be customized, extended, or selected based on your team's needs. Default roles include:

Agent	Role	Specialization
Architect	System design	Architecture decisions, ADRs, design reviews
Developer	Implementation	Code writing, refactoring, feature building
CodeReviewer	Quality gate	Code review, quality checks, suggestions
Tester	Quality assurance	Test writing, test execution, QA automation
Documenter	Knowledge keeper	Documentation, guides, API docs, root files
Marketer	Communications	Release notes, announcements, messaging
Presenter	Visualization	Presentations, demos, slide decks
DevOps	Deployment	Pipelines, deployment automation, infrastructure
Monitor	Operations	Health checks, alerting, observability
Security	Compliance	Security reviews, vulnerability scanning
ProjectManager	Planning	Roadmapping, tracking, prioritization
DecisionMaker	Resolution	Conflict resolution, decision arbitration

Agent Orchestration & Workflows

Solves: Dev-Ops Handoff Manual, Task Management Sin Inteligencia, Excessive LLM Costs

Agents work together seamlessly without manual coordination through the Workflow Orchestrator (vapora-workflow-engine):

• Multi-stage workflow execution:

  • Pre-configured templates (feature_development, bugfix, documentation_update, security_audit)
  • Sequential and parallel stage execution
  • Approval gates for governance and compliance
  • Artifact passing between stages (ADR, Code, TestResults, Review, Documentation)

• Cost-efficient agent coordination:

  • Short-lived agent contexts (terminate after task completion)
  • Context isolation (agents receive only what they need)
  • Artifact passing instead of conversation accumulation
  • ~95% reduction in cache token costs vs monolithic sessions
  • $840/month → ~$110/month for equivalent workload

• Parallel execution: Multiple agents work on different aspects simultaneously

  • Developer writes code while Tester writes tests
  • Documenter updates docs while DevOps prepares deployment

• Smart task assignment:

  • Based on agent expertise and availability
  • Consider agent workload and queue depth
  • Respect skill requirements of the task

• Dependency management:

  • Automatic task ordering based on dependencies
  • Deadlock detection and resolution
  • Critical path highlighting

• Approval gates:

  • Security agent approval for sensitive changes
  • Lead review approval before deployment
  • Multi-stage review workflows
  • API/CLI approval commands

• Intelligent fallback:

  • If agent fails, escalate or reassign
  • Use backup LLM model if primary fails
  • Retry with exponential backoff

• Learning & cost optimization (Phase 5.3 + 5.4):

  • Agents learn from execution history (per-task-type expertise)
  • Recent performance weighted 3x (last 7 days) for adaptive selection
  • Budget enforcement per role with automatic fallback
  • Cost-efficient routing with quality/cost ratio optimization
  • Real-time metrics and alerts via Prometheus/Grafana

• Kogral integration:

  • Context enrichment with guidelines, patterns, and ADRs
  • Persistent knowledge reduces session context bloat
  • Filesystem-based retrieval from .kogral/ directory

Learning-Based Agent Selection (Phase 5.3)

Solves: Inefficient agent assignment, static task routing

Agents improve continuously from execution history:

• Per-task-type learning profiles:

  • Each agent builds expertise scores for different task types
  • Success rate calculated from Knowledge Graph execution history
  • Confidence scoring prevents small-sample overfitting

• Recency bias for adaptive selection:

  • Recent executions weighted 3x (last 7 days)
  • Exponential decay prevents "permanent reputation"
  • Allows agents to recover from bad performance periods

• Intelligent scoring formula:

  • final_score = 0.3*load + 0.5*expertise + 0.2*confidence
  • Balances current workload with historical success
  • Confidence dampens high variance from few executions

• Learning curve visualization:

  • Track expertise improvement over time
  • Time-series analysis with daily/weekly aggregation
  • Identify agents needing additional training or tuning

Budget Enforcement & Cost Optimization (Phase 5.4)

Solves: Runaway LLM costs, unpredictable spending

Control costs with intelligent budget management:

• Per-role budget limits:

  • Configure monthly and weekly spending caps (in cents)
  • Separate budgets for Architect, Developer, Reviewer, etc.
  • Automatic weekly/monthly resets with carry-over option

• Three-tier enforcement:

  1. Normal operation: Rule-based routing with cost awareness
  2. Near threshold (>80%): Prefer cost-efficient providers
  3. Budget exceeded: Automatic fallback to cheaper alternatives

• Cost-efficient provider ranking:

  • Calculate quality/cost ratio: (quality * 100) / (cost + 1)
  • Quality from historical success rates per provider
  • Optimizes for value, not just lowest cost

• Fallback chain ordering:

  • Ollama (free local) → Gemini (cheap cloud) → OpenAI → Claude
  • Ensures tasks complete even when budget exhausted
  • Maintains quality at acceptable degradation level

• Real-time monitoring:

  • Prometheus metrics: budget remaining, utilization, fallback triggers

Workflow Orchestrator (v1.2.0)

Solves: Excessive LLM cache token costs, monolithic session patterns

Execute multi-stage pipelines with short-lived agent contexts for cost-efficient workflows:

• ~95% reduction in cache token costs:

  • Monolithic session: ~$840/month (3.82B cache tokens)
  • Multi-stage workflow: ~$110/month (640K cache tokens)
  • Agents terminate after task completion, context discarded

• Pre-configured workflow templates:

  • feature_development (5 stages): architecture → implementation (parallel) → testing → review (approval) → deployment (approval)
  • bugfix (4 stages): investigation → fix → testing → deployment
  • documentation_update (3 stages): content → review (approval) → publish
  • security_audit (4 stages): analysis → pentesting → remediation → verification (approval)

• Artifact passing between stages:

  • ADR (Architecture Decision Record)
  • Code (source files)
  • TestResults (execution output)
  • Review (feedback)
  • Documentation (generated docs)
  • Custom (user-defined)

• Approval gates for governance:

  • Stage pauses until manual approval
  • API/CLI approval commands
  • Approver name logged in audit trail
  • NATS events published (vapora.workflow.approval_required)

• Kogral integration for context enrichment:

  • Guidelines from .kogral/guidelines/{workflow}.md
  • Patterns from .kogral/patterns/*.md
  • Recent ADRs from .kogral/adrs/*.md (5 most recent)
  • Reduces session context by storing knowledge persistently

• REST API & CLI:

  • Start workflow: POST /api/v1/workflow_orchestrator or vapora workflow start
  • List workflows: GET /api/v1/workflow_orchestrator or vapora workflow list
  • Get status: GET /api/v1/workflow_orchestrator/:id or vapora workflow status <id>
  • Approve stage: POST /api/v1/workflow_orchestrator/:id/approve or vapora workflow approve <id>
  • Cancel workflow: POST /api/v1/workflow_orchestrator/:id/cancel or vapora workflow cancel <id>
  • List templates: GET /api/v1/workflow_orchestrator/templates or vapora workflow templates

• Prometheus metrics:

  • vapora_workflows_started_total - Total workflows initiated
  • vapora_workflows_completed_total - Successfully finished
  • vapora_workflows_failed_total - Failed workflows
  • vapora_active_workflows - Currently running (gauge)
  • vapora_stage_duration_seconds - Stage execution time histogram
  • vapora_workflow_duration_seconds - Total workflow time histogram

See: Workflow Orchestrator Guide | CLI Commands | ADR-0028

• Grafana dashboards: visual budget tracking per role

• Alerts at 80%, 90%, 100% utilization thresholds

• Cost tracking granularity:

  • Per provider (Claude, OpenAI, Gemini, Ollama)
  • Per agent role (Architect, Developer, etc.)
  • Per task type (coding, review, documentation)
  • Per token (input/output separated)

Workflow Definition & Execution

Define complex workflows as YAML, Vapora executes automatically:

workflow:
  name: "Feature Implementation"
  stages:
    - architect:
        task: "Design feature architecture"
        requires: [issue_description]

    - parallel:
        - develop:
            task: "Implement feature"
            requires: [architecture]
        - test_planning:
            task: "Plan test strategy"
            requires: [architecture]

    - test:
        task: "Write and run tests"
        requires: [develop, test_planning]

    - review:
        task: "Code review"
        requires: [develop]
        approval_required: true

    - document:
        task: "Update docs"
        requires: [develop]

    - deploy:
        task: "Deploy to staging"
        requires: [review, test, document]

Vapora handles:

• State machine execution (state transitions with validation)
• Conditional branches (if/else logic)
• Parallel stages (multiple agents work simultaneously)
• Approval gates (halt until approval received)
• Error handling (catch failures, retry, escalate)
• Rollback on failure (revert to previous state if needed)
• Real-time progress tracking (live dashboard with WebSocket updates)

Agent-to-Agent Communication

• NATS JetStream pub/sub messaging
• Request/Reply pattern for synchronous operations
• Broadcast events (task completed, blocker detected, etc.)
• Shared context via Model Context Protocol (MCP)
• Complete audit trail of all agent interactions

---

Knowledge Management

Session Lifecycle Manager

Solves: Knowledge Fragmentado

Every work session is automatically organized and searchable:

• Automatic organization of all session artifacts:

  • Tasks created/updated
  • Decisions made
  • Code changes
  • Discussions and comments
  • Generated documentation

• Session metadata:

  • Date and time
  • Participants (humans + agents)
  • Goals and outcomes
  • Key decisions
  • Issues discovered

• Decision extraction:

  • Auto-generate Architecture Decision Records (ADRs) from discussions
  • Capture "why" behind decisions
  • Link to related decisions
  • Track decision impact

• Context preservation:

  • Complete task history
  • All comments and discussions
  • Code changes and diffs
  • Referenced resources

• Searchable archive:

  • Find past sessions by topic
  • Discover who worked on similar problems
  • Understand project history and evolution
  • Learn from past decisions

Root Files Keeper

Solves: Knowledge Fragmentado, Dev-Ops Handoff Manual

Critical project files stay accurate and up-to-date automatically:

• README.md - Always reflects current project state

  • Quick start instructions (updated when setup changes)
  • Feature list (reflects completed features)
  • Architecture overview (updated when architecture changes)
  • Latest version and changelog link

• CHANGELOG.md - Complete release history

  • Auto-populated from releases and completed features
  • Organized by version
  • Breaking changes highlighted

• ROADMAP.md - Future direction and planning

  • Planned features and their status
  • Timeline and priorities
  • Known issues and limitations

• CONTRIBUTING.md - Development guidelines

  • Setup instructions
  • Development workflow
  • Code style guidelines
  • Testing requirements
  • Pull request process

• Additional files:

  • SECURITY.md (security policies)
  • API.md (API documentation)
  • ARCHITECTURE.md (system design)
  • Custom files per project

• Smart updates:

  • Backup before any update (never lose old content)
  • Diff tracking (see what changed)
  • Version control (roll back if needed)
  • Human review optional (approve updates before publishing)

Documentation Lifecycle

Solves: Knowledge Fragmentado

All documentation is continuously organized and indexed:

• Automatic classification:

  • Specifications and design docs
  • Architecture Decision Records (ADRs)
  • How-to guides and tutorials
  • API documentation
  • Troubleshooting guides
  • Meeting notes and decisions

• Intelligent organization:

  • By category, project, date
  • Automatic tagging
  • Relationship linking

• RAG indexing:

  • All docs become searchable
  • Part of semantic search results
  • Linked to related code and tasks

• Auto-archival:

  • Old docs marked as deprecated
  • Obsolete docs archived (not deleted)
  • Version history preserved

• Presentation generation:

  • Auto-generate slide decks from docs
  • Create summary presentations
  • Export to multiple formats

• Impact tracking:

  • Which code implements which spec?
  • Which ADR impacts this feature?
  • Doc change history

---

Cloud-Native & Deployment

Standalone Local Development

Solves: Context Switching Infinito, Dev-Ops Handoff Manual

Get started in 5 minutes with Docker Compose:

git clone https://github.com/vapora-platform/vapora.git
cd vapora
docker compose up -d

# Access:
# Frontend: http://localhost:3000
# Backend API: http://localhost:8080
# Database: http://localhost:8000

Includes everything out of the box:

• Frontend (Leptos WASM application)
• Backend API (Axum REST + WebSocket)
• Database (SurrealDB)
• Message queue (NATS JetStream)
• Cache layer (Redis)

Perfect for:

• Local development
• Team collaboration on local network
• Small team deployments
• Testing before Kubernetes deployment

Kubernetes Deployment

Deploy to any Kubernetes cluster—no vendor lock-in:

Supported platforms:

• Vanilla Kubernetes
• Amazon EKS
• Google GKE
• Azure AKS
• DigitalOcean Kubernetes
• Self-hosted K3s, RKE2
• On-premise Kubernetes

Deployment approaches:

1. Helm Charts (traditional Kubernetes)

   • Standard Helm values
   • Customizable for your environment
   • GitOps-friendly

2. Provisioning (Infrastructure as Code)

   • KCL-based configuration
   • Declarative infrastructure
   • Complete cluster setup automation
   • Integrated with existing Provisioning platform

Scaling & High Availability

• Auto-scaling agents (HPA based on queue depth)
• Load balancing across service replicas
• Database replication (SurrealDB multi-node)
• Distributed caching (Redis cluster)
• Message queue scaling (NATS cluster)
• Zero-downtime deployments (rolling updates)

Infrastructure as Code

Define infrastructure declaratively:

[cluster]
name = "vapora-prod"
cloud = "aws"
region = "us-west-2"
availability_zones = 3

[services.backend]
replicas = 3
cpu = "500m"
memory = "1Gi"

[services.agents]
replicas = 5 # scales up to 20 based on load
cpu = "1000m"
memory = "2Gi"

[storage]
database = "50Gi"
cache = "10Gi"

---

Security & Multi-Tenancy

Authentication & Authorization

• JWT-based authentication (API tokens, session tokens)
• Cedar policy engine for fine-grained access control
• Flexible roles (Admin, Lead, Developer, Agent, Viewer)
• Custom policies (e.g., "only Architect agents can approve ADRs")
• Team-based permissions (fine-grained per team/project)
• Audit logging (all actions logged with who, what, when)

Multi-Tenancy by Design

Solves: Shared platform infrastructure for platform teams

• Namespace isolation (each tenant in separate namespace)
• Database scopes (SurrealDB native scoping for data isolation)
• Network policies (prevent cross-tenant traffic)
• Resource quotas (enforce limits per tenant)
• Separate secrets per tenant (no credential leakage)
• Isolated storage (persistent volumes per tenant)

Data Protection

• Encryption at rest (TLS certificates, encrypted volumes)
• Encryption in transit (mTLS between services)
• Secrets management (RustyVault integration)
• API key rotation (automatic and manual)
• Data backup (automated, encrypted, off-site)
• Data deletion (GDPR-compliant, with audit trail)

Compliance Ready

• Audit trails (immutable logs of all actions)
• Compliance policies (SOC 2, HIPAA, GDPR)
• Access logs (who accessed what, when)
• Change tracking (what changed, who changed it)
• Data residency (control where data is stored)
• Compliance reports (auto-generate audit reports)

---

Technology Stack

Backend

• Rust 1.75+ - Performance, memory safety, concurrency
• Axum 0.7 - Fast, ergonomic web framework
• SurrealDB 1.8 - Multi-model database with built-in scoping for multi-tenancy
• NATS JetStream - High-performance message queue for agent coordination
• Tokio - Async runtime for concurrent operations

Frontend

• Leptos 0.6 - Reactive Rust framework for WASM
• UnoCSS - Atomic CSS for instant, on-demand styling
• thaw - Component library
• leptos-use - Reactive utilities

Agents & LLM

• Rig - LLM agent framework with tool calling
• NATS JetStream - Inter-agent coordination and messaging
• Cedar - Policy engine for fine-grained RBAC
• MCP Gateway - Model Context Protocol for plugin extensibility
• LLM support: Claude, OpenAI, Google Gemini, Ollama (local)
• fastembed - Local embeddings for RAG (privacy-first)

Infrastructure

• Kubernetes - Orchestration (K3s, RKE2, vanilla, managed)
• Istio - Service mesh (mTLS, traffic management, observability)
• Rook Ceph - Distributed storage (high availability)
• Tekton - CI/CD pipelines (if using Provisioning)
• RustyVault - Secrets management
• Prometheus + Grafana - Monitoring and alerting
• Loki - Log aggregation
• Tempo - Distributed tracing
• Zot - OCI registry (lightweight artifact storage)

---

📊 Metrics & Monitoring

Built-in Dashboards

• Project overview: Tasks, completion rate, team velocity
• Agent metrics: Execution time, token usage, error rates
• Team burndown: Sprint progress, velocity trends
• Code metrics: Complexity, coverage, quality scores
• Deployment status: Success rates, lead time, cycle time

Observability

• Structured logging (JSON format, searchable)
• Distributed tracing (OpenTelemetry compatible)
• Metrics (Prometheus format)
• Health checks (liveness and readiness probes)
• Custom dashboards (build your own)
• Alerting (notifications when thresholds exceeded)

---

🚀 Roadmap Features (Future)

• Mobile app for on-the-go task management
• IDE integrations (VS Code, JetBrains, Vim)
• Advanced AI (model fine-tuning per team)
• Custom agents (create domain-specific agents)
• Compliance automation (SOC 2, HIPAA, GDPR)
• Cost analytics (track agent execution costs)
• Agent marketplace (publish/share community agents)
• Managed hosting (Vapora Cloud option)
• Time tracking (automatic time estimation and tracking)
• Resource planning (capacity planning, workload balancing)

---

Optional Integrations

Vapora is a complete, standalone platform. These integrations are optional—use them only if you want to connect with external systems:

External Repository Sync

Optionally sync with external repositories:

• Periodic sync (pull data from external sources)
• One-way or two-way sync (depending on use case)
• Conflict resolution (when both systems have changes)
• Mapping configuration (field mappings for different schemas)

Examples:

• Sync tasks from external issue tracker
• Sync pull requests to see deployment readiness
• Sync documentation from wiki

Note: Vapora's native task management, repository browser, and documentation system eliminate the need for external tools for most teams.

External LLM Providers

Use Vapora's multi-LLM router with external providers:

• Claude (Anthropic)
• GPT-4 / GPT-4o (OpenAI)
• Gemini (Google)
• Ollama (local models)

Vapora intelligently routes tasks to the optimal provider based on:

• Task complexity
• Required latency
• Cost considerations
• Model capabilities

Note: All LLM access is configured via API keys in Vapora's secrets management. Your data stays within your deployment.

MCP Plugin System

Extend Vapora capabilities via Model Context Protocol (MCP):

• Standard plugin interface for tools and resources
• Community plugins for common integrations
• Custom plugins for domain-specific needs
• Secure execution (sandboxed)

Examples of possible plugins:

• External repository browser
• Issue tracker sync
• Documentation aggregator
• Custom notification system

Custom Webhooks & APIs

Integrate with external systems via APIs:

• Outgoing webhooks (send events when tasks change)
• Incoming webhooks (receive updates from external systems)
• REST API (build custom integrations)
• GraphQL API (if using advanced queries)

---

Getting Started

For Individual Developers

1. Quick Start Guide
2. Task Management Guide
3. AI Agent Features

For Development Teams

1. Team Setup Guide
2. Collaboration Guide
3. Workflow Configuration

For DevOps/Platform Teams

1. Deployment Guide
2. Kubernetes Setup
3. Multi-Tenancy Setup
4. Monitoring & Operations

For Extensibility

1. MCP Plugin Guide
2. API Reference
3. Webhook Documentation

---

More Information

• Website: https://vapora.dev
• Documentation: https://docs.vapora.dev
• GitHub: https://github.com/vapora-platform/vapora
• Community: https://discord.gg/vapora
• Issues & Feedback: https://github.com/vapora-platform/vapora/issues

---

Made with vaporwave dreams and Rust reality ✨

Last updated: November 2025 | Version: 0.1.0 (Specification)