diff --git a/assets/images/platform/billing/billing_tab.png b/assets/images/platform/billing/billing_tab.png new file mode 100644 index 000000000..14d1b6bb0 Binary files /dev/null and b/assets/images/platform/billing/billing_tab.png differ diff --git a/assets/images/platform/billing/stripe_portal.png b/assets/images/platform/billing/stripe_portal.png new file mode 100644 index 000000000..50d80697a Binary files /dev/null and b/assets/images/platform/billing/stripe_portal.png differ diff --git a/assets/images/platform/infrastructure/new_project_button.png b/assets/images/platform/infrastructure/new_project_button.png new file mode 100644 index 000000000..0e7d958e4 Binary files /dev/null and b/assets/images/platform/infrastructure/new_project_button.png differ diff --git a/assets/images/platform/infrastructure/plan_type_selection.png b/assets/images/platform/infrastructure/plan_type_selection.png new file mode 100644 index 000000000..d8b66d9cd Binary files /dev/null and b/assets/images/platform/infrastructure/plan_type_selection.png differ diff --git a/assets/images/platform/infrastructure/project_creating.png b/assets/images/platform/infrastructure/project_creating.png new file mode 100644 index 000000000..3fa050086 Binary files /dev/null and b/assets/images/platform/infrastructure/project_creating.png differ diff --git a/assets/images/platform/infrastructure/resource_based_config.png b/assets/images/platform/infrastructure/resource_based_config.png new file mode 100644 index 000000000..cd955246e Binary files /dev/null and b/assets/images/platform/infrastructure/resource_based_config.png differ diff --git a/assets/images/platform/infrastructure/usage_based_config.png b/assets/images/platform/infrastructure/usage_based_config.png new file mode 100644 index 000000000..3d828c42a Binary files /dev/null and b/assets/images/platform/infrastructure/usage_based_config.png differ diff --git a/assets/images/platform/infrastructure/version_update_available.png b/assets/images/platform/infrastructure/version_update_available.png new file mode 100644 index 000000000..8bcfb55c9 Binary files /dev/null and b/assets/images/platform/infrastructure/version_update_available.png differ diff --git a/assets/images/platform/infrastructure/version_update_modal.png b/assets/images/platform/infrastructure/version_update_modal.png new file mode 100644 index 000000000..459d51f65 Binary files /dev/null and b/assets/images/platform/infrastructure/version_update_modal.png differ diff --git a/assets/images/platform/infrastructure/version_updating.png b/assets/images/platform/infrastructure/version_updating.png new file mode 100644 index 000000000..3612fa3ce Binary files /dev/null and b/assets/images/platform/infrastructure/version_updating.png differ diff --git a/assets/images/platform/management/experimental_features.png b/assets/images/platform/management/experimental_features.png new file mode 100644 index 000000000..13183650e Binary files /dev/null and b/assets/images/platform/management/experimental_features.png differ diff --git a/assets/images/platform/management/webhooks_add.png b/assets/images/platform/management/webhooks_add.png new file mode 100644 index 000000000..368475457 Binary files /dev/null and b/assets/images/platform/management/webhooks_add.png differ diff --git a/assets/images/platform/management/webhooks_empty.png b/assets/images/platform/management/webhooks_empty.png new file mode 100644 index 000000000..b0bb9ca7f Binary files /dev/null and b/assets/images/platform/management/webhooks_empty.png differ diff --git a/assets/images/platform/monitoring/api_calls.png b/assets/images/platform/monitoring/api_calls.png new file mode 100644 index 000000000..3845b8712 Binary files /dev/null and b/assets/images/platform/monitoring/api_calls.png differ diff --git a/assets/images/platform/monitoring/bandwidth.png b/assets/images/platform/monitoring/bandwidth.png new file mode 100644 index 000000000..667312c1d Binary files /dev/null and b/assets/images/platform/monitoring/bandwidth.png differ diff --git a/assets/images/platform/monitoring/batch_detail.png b/assets/images/platform/monitoring/batch_detail.png new file mode 100644 index 000000000..d38d813c5 Binary files /dev/null and b/assets/images/platform/monitoring/batch_detail.png differ diff --git a/assets/images/platform/monitoring/batches_list.png b/assets/images/platform/monitoring/batches_list.png new file mode 100644 index 000000000..c95cf1297 Binary files /dev/null and b/assets/images/platform/monitoring/batches_list.png differ diff --git a/assets/images/platform/monitoring/indexing_latency.png b/assets/images/platform/monitoring/indexing_latency.png new file mode 100644 index 000000000..30e694ac4 Binary files /dev/null and b/assets/images/platform/monitoring/indexing_latency.png differ diff --git a/assets/images/platform/monitoring/search_latency.png b/assets/images/platform/monitoring/search_latency.png new file mode 100644 index 000000000..be2c74ca7 Binary files /dev/null and b/assets/images/platform/monitoring/search_latency.png differ diff --git a/assets/images/platform/monitoring/search_performance_trace.png b/assets/images/platform/monitoring/search_performance_trace.png new file mode 100644 index 000000000..ee6161cc1 Binary files /dev/null and b/assets/images/platform/monitoring/search_performance_trace.png differ diff --git a/assets/images/platform/monitoring/search_qps.png b/assets/images/platform/monitoring/search_qps.png new file mode 100644 index 000000000..9e89aaaa7 Binary files /dev/null and b/assets/images/platform/monitoring/search_qps.png differ diff --git a/broken-links.txt b/broken-links.txt new file mode 100644 index 000000000..ef3d1d681 --- /dev/null +++ b/broken-links.txt @@ -0,0 +1,14 @@ +5 broken internal link(s) across 4 file(s): + + capabilities/full_text_search/advanced/debug_search_performance.mdx + line 98: /resources/self_hosting/sharding + + capabilities/indexing/how_to/document_relations.mdx + line 142: /resources/self_hosting/sharding + line 148: /reference/api/settings/get-foreign-keys + + resources/help/experimental_features_overview.mdx + line 69: /capabilities/personalization/getting_started + + resources/self_hosting/enterprise_edition.mdx + line 14: /resources/self_hosting/sharding diff --git a/capabilities/overview.mdx b/capabilities/overview.mdx index 4a4d6d8f8..fe68eb65c 100644 --- a/capabilities/overview.mdx +++ b/capabilities/overview.mdx @@ -34,7 +34,7 @@ Meilisearch provides a comprehensive set of search and data management capabilit Control access with API keys and tenant tokens for multi-tenant applications. - + Manage collaborators and roles in Meilisearch Cloud projects. diff --git a/capabilities/platform/billing/invoices.mdx b/capabilities/platform/billing/invoices.mdx new file mode 100644 index 000000000..e7ef3a58d --- /dev/null +++ b/capabilities/platform/billing/invoices.mdx @@ -0,0 +1,14 @@ +--- +title: Invoices +description: View and download your Meilisearch Cloud invoice history through the Stripe customer portal. +--- + +Invoices are managed through Stripe. To access your invoice history, open the **Billing** tab in the Cloud dashboard and click **Manage billing settings and invoices**. This opens the Stripe customer portal. + + + Stripe customer portal showing invoice history with dates, amounts, and paid status + + +The **Invoice history** section in the Stripe portal lists all past invoices with their date, amount, and payment status. Click any invoice to view its details or download a PDF. + +If you need to update the billing name, address, or Tax ID shown on invoices, click **Update information** in the portal. diff --git a/capabilities/platform/billing/overview.mdx b/capabilities/platform/billing/overview.mdx new file mode 100644 index 000000000..17a4f4a38 --- /dev/null +++ b/capabilities/platform/billing/overview.mdx @@ -0,0 +1,47 @@ +--- +title: Billing +sidebarTitle: Overview +description: Understand how Meilisearch Cloud billing works, view your estimated next bill, and manage payment settings through Stripe. +--- + +Meilisearch Cloud billing is fully powered by Stripe. The **Billing** tab in the Cloud dashboard shows a summary of your current billing settings and an estimate of your next bill. For invoice history, payment methods, and billing information, click **Manage billing settings and invoices** to open the Stripe customer portal. + +## Billing models + +| | Resource-based | Usage-based | +|---|---|---| +| **What you pay for** | Fixed CPU, RAM, and storage allocation | Number of searches and documents indexed | +| **Billing cycle** | Hourly (prorated) | Monthly | +| **Price predictability** | High | Varies with traffic | + +See [project types](/capabilities/platform/infrastructure/overview#resource-based-vs-usage-based-projects) for guidance on which model to choose. + +## The Billing tab + + + Meilisearch Cloud Billing tab showing billing settings, payment method, and estimated cost for next bill + + +The Billing tab shows: + +- **Billing settings**: your current Tax ID and default payment method +- **Manage billing settings and invoices**: button to open the Stripe portal for full billing management +- **Estimated cost for next bill**: a line-by-line breakdown of charges accrued in the current billing period, covering all active projects + +## What affects your bill + +Only active projects generate charges. Deleting a project stops billing immediately. Team members and API keys do not affect billing. + +## Next steps + + + + How billing works, resource pricing, and cost estimation + + + View and download your billing history via Stripe + + + Add or update payment methods via Stripe + + diff --git a/capabilities/platform/billing/payment_methods.mdx b/capabilities/platform/billing/payment_methods.mdx new file mode 100644 index 000000000..ac820a06a --- /dev/null +++ b/capabilities/platform/billing/payment_methods.mdx @@ -0,0 +1,18 @@ +--- +title: Payment methods +description: Add or update payment methods for your Meilisearch Cloud account through the Stripe customer portal. +--- + +Payment methods are managed through Stripe. To add, change, or remove a payment method, open the **Billing** tab in the Cloud dashboard and click **Manage billing settings and invoices**. This opens the Stripe customer portal. + + + Stripe customer portal showing payment method management with option to add a new payment method + + +In the **Payment method** section of the portal: + +- Click **+ Add payment method** to add a new card +- Click the **×** next to an existing card to remove it +- The card marked **Default** is the one charged automatically on each billing cycle + +If a payment fails, Meilisearch Cloud will notify you by email. Update your payment method promptly to avoid service interruption. diff --git a/capabilities/platform/billing/pricing_model.mdx b/capabilities/platform/billing/pricing_model.mdx new file mode 100644 index 000000000..9ee9d01bd --- /dev/null +++ b/capabilities/platform/billing/pricing_model.mdx @@ -0,0 +1,112 @@ +--- +title: Pricing model +description: How Meilisearch Cloud billing works for resource-based and usage-based projects, including pricing and cost estimation. +--- + +Meilisearch Cloud bills each project independently. Resource-based projects are billed hourly (prorated), while usage-based projects follow a monthly cycle. +## Resource-based pricing + +Resource-based projects are billed at an hourly rate based on the resource tier you select (Memory and vCPU). You pay for the resources you provision, regardless of how many searches you run or documents you index. + +The Cloud UI shows the hourly rate and estimated monthly cost for each tier at project creation and in the project settings. Pricing may vary slightly by region. + +## Usage-based pricing + +Usage-based projects are billed on what your project actually consumes. There are three plans: + +| Plan | Included searches | Extra searches | Included documents | Extra documents | Resources | +|------|------------------|----------------|--------------------|-----------------|-----------| +| **Build** | 50K/month | $0.40 per 1,000 | 100K | $0.30 per 1,000 | Shared | +| **Pro** | 250K/month | $0.30 per 1,000 | 1M | $0.20 per 1,000 | Dedicated | + +Resources scale automatically. You do not choose a tier. The Cloud UI shows your accrued costs based on recent usage. + +### How usage-based billing is charged + +- **Plan cost**: the base plan fee (Build or Pro) is charged upfront at the start of each billing cycle. +- **Extra usage**: searches and documents beyond the included quota are charged at the end of the billing cycle, once the total is known. +- **Cancellation**: if you cancel your plan before the end of the month, the unused portion of the base plan fee is prorated and returned as a credit. +- **Outstanding usage**: if you remove your payment method while extra usage charges are still outstanding, Meilisearch will follow up to collect the owed amount. + +## Shared billing rules + +Regardless of billing model: + +- **Per-project billing.** Each project is billed independently. A team with multiple projects is billed the sum of all project charges. +- **Prorated daily cycle.** Creating or deleting a project mid-day adjusts the charge proportionally. +- **No per-seat fees.** Adding team members does not affect billing. + +## Regions and pricing + +Pricing may vary slightly by region. The Cloud UI shows the exact price for your selected region. + +| Region | Location | +|--------|----------| +| `FRA` | Frankfurt | +| `LON` | London | +| `SGP` | Singapore | +| `JPN` | Japan | +| `SFO` | San Francisco | +| `NYC` | New York | + +## Choosing a resource tier + +For resource-based projects, the most important factor is **RAM**: Meilisearch keeps indexes in memory for fast search, so your instance needs enough RAM to hold your index comfortably. + +### Step 1: Estimate your index size + +Your index size depends on how many documents you have and how large each document is. Use these typical document sizes as a starting point: + +| Document type | Avg size | Examples | +|--------------|----------|---------| +| Small | ~1 KB | SaaS records, simple product listings with few filters | +| Medium | ~3 KB | E-commerce products with descriptions and ~10 filterable attributes | +| Large | ~8 KB | Articles, blog posts, rich content | +| AI (with vectors) | ~12 KB | Any document type with vector embeddings | + +**Formula:** + +``` +Index size ≈ number of documents × average document size × 5 +``` + +The ×5 factor accounts for the inverted index, facet data, prefix structures, and other internal data Meilisearch builds from your documents. + +**Examples:** + +| Documents | Avg size | Estimated index size | +|-----------|----------|---------------------| +| 100K | 3 KB (medium) | ~1.4 GB | +| 500K | 3 KB (medium) | ~7 GB | +| 100K | 12 KB (AI) | ~5.7 GB | +| 1M | 8 KB (large) | ~37 GB | + +### Step 2: Choose a tier with enough RAM + +Choose the smallest tier where **RAM exceeds your estimated index size**. Leave headroom for query cache and peak usage. + +| Tier | vCPU | RAM | Suitable for | +|------|------|-----|-------------| +| XS | 0.5 | 1 GB | Development and testing | +| S | 1 | 2 GB | Up to ~80K small documents | +| M | 2 | 4 GB | Up to ~80K medium or ~160K small documents | +| L | 2 | 8 GB | Up to ~400K medium documents | +| XL | 4 | 16 GB | Up to ~800K medium or ~300K AI documents | +| 2XL | 8 | 32 GB | Up to ~1.6M medium or ~600K AI documents | +| 4XL | 16 | 64 GB | Up to ~3M medium or ~1.2M AI documents | + +For larger workloads, contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to discuss Enterprise options including [sharding and replication](/capabilities/platform/infrastructure/sharding_and_replication). + +### Step 3: Consider vCPU for high query volume + +RAM is almost always the bottleneck. However, if your workload involves sustained high QPS (hundreds of searches per second), choose a tier with more vCPUs. Tiers L and below share 2 vCPUs, while XL and above provide dedicated cores. + +### Interactive estimator + +Use the [pricing page calculator](https://www.meilisearch.com/pricing) to get a recommendation based on your document count, document type, and expected search volume. + +## Estimating your costs + +**Resource-based projects:** the Cloud UI shows the hourly rate and an estimated monthly cost for each tier. You can also multiply the hourly rate by 730 for a full-month estimate. + +**Usage-based projects:** monitor the accrued cost shown in the Cloud UI over the first few days and extrapolate. Costs scale with search volume and document count, so factor in expected traffic growth. diff --git a/capabilities/platform/infrastructure/backups.mdx b/capabilities/platform/infrastructure/backups.mdx new file mode 100644 index 000000000..70580dce0 --- /dev/null +++ b/capabilities/platform/infrastructure/backups.mdx @@ -0,0 +1,30 @@ +--- +title: Backups +description: Meilisearch Cloud automatically backs up your project data on a weekly schedule, with customizable options for Enterprise customers. +--- + +Meilisearch Cloud automatically backs up your project data. Backups protect against accidental data loss and allow you to restore a project to a previous state. + +## Default backup schedule + +| Setting | Default | +|---------|---------| +| Frequency | Once per week | +| Backups retained | 2 (the two most recent) | +| Scheduled day | Based on the day the project was created | + +The backup window is automatically set when you create a project. Older backups are discarded as new ones are created, so only the two most recent backups are kept at any time. + +## Restoring from a backup + +To restore your project from a backup, contact [support@meilisearch.com](mailto:support@meilisearch.com) with your project name and the date you want to restore to. + +## Enterprise backup customization + +Enterprise customers can fully customize their backup configuration: + +- **Frequency**: daily, multiple times per day, or any custom schedule +- **Retention**: keep more than 2 backups +- **Timing**: choose the exact time backups run to avoid peak traffic periods + +Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to configure a custom backup policy for your project. diff --git a/capabilities/platform/infrastructure/create_a_project.mdx b/capabilities/platform/infrastructure/create_a_project.mdx new file mode 100644 index 000000000..e1f943adb --- /dev/null +++ b/capabilities/platform/infrastructure/create_a_project.mdx @@ -0,0 +1,84 @@ +--- +title: Create a project +description: Create a new Meilisearch Cloud project from the dashboard in a few steps. +--- + +{/* Screenshots needed on this page: + 1. The project dashboard after successful creation (API keys, search preview) +*/} + +A project is an isolated Meilisearch instance. Creating one takes two steps: choose a plan type, then configure the project. + +## Prerequisites + +- A Meilisearch Cloud account. [Sign up at cloud.meilisearch.com](https://cloud.meilisearch.com) if you do not have one. + +## Step 1: Click "New project" + +From the [Cloud dashboard](https://cloud.meilisearch.com), click the **New project** button. + + + Meilisearch Cloud projects list with the New project button + + +## Step 2: Choose a plan type + +You will be asked to choose between two billing models: + +| Plan type | Description | +|-----------|-------------| +| **Resource-Based** | Select compute and storage to match your performance needs. You pay a fixed hourly rate for the resources you provision. | +| **Usage-Based** | Pay as you go. Costs adjust automatically based on your actual searches and documents. | + +See [Resource-based vs usage-based](/capabilities/platform/infrastructure/overview#resource-based-vs-usage-based-projects) for guidance on which to choose. + + + Create project modal showing Resource-Based and Usage-Based plan type options + + +## Step 3: Configure the project + +Both plan types share three common fields: + +| Field | Description | +|-------|-------------| +| **Project name** | Between 3 and 40 characters. | +| **Region** | The region where your project is hosted. Cannot be changed after creation. See [Regions](/capabilities/platform/infrastructure/regions). | +| **Meilisearch version** | The version to deploy. Defaults to the latest stable release. | + +### Resource-Based configuration + +Select a resource tier (Memory and vCPU). The Cloud UI shows the hourly cost and estimated monthly cost for the selected tier. See [resource-based pricing](/capabilities/platform/billing/pricing_model#resource-based-pricing) for more details. + + + Configure resource-based project form showing memory, vCPU, and hourly cost breakdown + + +### Usage-Based configuration + +Select a plan: + +| Plan | Included searches | Included documents | Resources | Support | +|------|------------------|--------------------|-----------|---------| +| **Build** | 50K/month, then $0.40 per 1,000 | 100K, then $0.30 per 1,000 | Shared | Community (Discord) | +| **Pro** | 250K/month, then $0.30 per 1,000 | 1M, then $0.20 per 1,000 | Dedicated | Meilisearch team | + +See [usage-based pricing](/capabilities/platform/billing/pricing_model#usage-based-pricing) for more details. + + + Configure usage-based project form showing Build and Pro plan options with pricing details + + +## Step 4: Create the project + +Click **Create project**. Meilisearch Cloud provisions the instance. The project appears in your dashboard with a **creating** status while it is being provisioned, then becomes available in a few seconds. + + + Meilisearch Cloud projects list showing a project with creating status + + +## Next steps + +- [Add documents](/getting_started/first_project) using your project's API URL and admin key +- [Manage resources](/capabilities/platform/infrastructure/manage_resources) to scale as your data grows +- [Invite team members](/capabilities/platform/teams/overview) to collaborate on the project diff --git a/capabilities/platform/infrastructure/manage_resources.mdx b/capabilities/platform/infrastructure/manage_resources.mdx new file mode 100644 index 000000000..33d14221b --- /dev/null +++ b/capabilities/platform/infrastructure/manage_resources.mdx @@ -0,0 +1,67 @@ +--- +title: Manage resources +description: Scale your Meilisearch Cloud project's CPU and RAM up or down from the project settings. +--- + +{/* Screenshots needed on this page: + 1. The resource settings panel in project settings (current plan, available tiers) + 2. The plan selection UI showing available tiers with CPU/RAM/price +*/} + + + Resource management applies to **resource-based projects** only. Usage-based projects scale automatically and do not have a configurable resource tier. If you are on a usage-based plan and want more control over your infrastructure, you can migrate to a resource-based project at any time by creating a new resource-based project and re-indexing your data. + + +You can change a project's resource tier at any time from the Meilisearch Cloud project settings. Scaling up increases available CPU and RAM, scaling down reduces costs. + +## Resource tiers + +Each tier defines the CPU, RAM, and storage available to your project. The exact tiers and their prices are shown in the Cloud UI and on the [Meilisearch pricing page](https://www.meilisearch.com/pricing). + +General guidelines for choosing a tier: + +| Situation | Guidance | +|-----------|----------| +| Index fits comfortably in RAM | Keep a tier where RAM exceeds your index size by at least 20% | +| High query volume (hundreds of QPS) | Choose a tier with more CPU cores | +| Large vector dimensions or many embedded documents | Prefer higher RAM tiers; vector indexes grow quickly | +| Development or staging environment | Use the smallest tier to minimize cost | + +## When to scale up + +Signs that your project needs more resources: + +- Search latency (p95 or p99) increases during peak traffic +- Indexing tasks take significantly longer than usual +- Memory usage stays near 100% in the [usage metrics dashboard](/capabilities/platform/monitoring/usage_metrics) +- CPU usage is consistently high during search-heavy periods + +## Changing the plan + +1. Open your project in the Meilisearch Cloud dashboard. +2. Go to **Settings** and find the **Resource plan** section. +3. Click **Change plan**. + + + **Screenshot needed:** Replace this placeholder with a screenshot of the resource settings panel showing the current plan and a "Change plan" button before publishing. + + + + Meilisearch Cloud project resource settings panel + + +4. Select the desired tier from the plan picker. + + + **Screenshot needed:** Replace this placeholder with a screenshot of the plan selection UI showing available tiers with CPU, RAM, and pricing information before publishing. + + + + Meilisearch Cloud plan selection UI showing available resource tiers + + +5. Click **Confirm**. The change takes effect shortly. Search and indexing operations remain available during the transition on most plan changes. + +## Impact on billing + +Resource-based projects are billed by the hour. When you change resource tiers, the new rate applies from the next hour. You are never double-billed: at most, you may be charged for a partial hour at the old rate before the new rate kicks in. See [Pricing model](/capabilities/platform/billing/pricing_model) for details. diff --git a/capabilities/platform/infrastructure/overview.mdx b/capabilities/platform/infrastructure/overview.mdx new file mode 100644 index 000000000..8ebbddd2a --- /dev/null +++ b/capabilities/platform/infrastructure/overview.mdx @@ -0,0 +1,89 @@ +--- +title: Cloud infrastructure +sidebarTitle: Overview +description: Understand Meilisearch Cloud projects, available regions, and resource tiers for hosting your search instances. +--- + +Infrastructure is the foundation of Meilisearch Cloud. Every search experience you build starts with a **project**: a fully isolated Meilisearch instance with its own indexes, API keys, settings, and resource allocation. + +## Projects + +A project is the core unit of Meilisearch Cloud. Think of it as a dedicated Meilisearch server: + +- Each project has its own indexes and documents +- Each project has its own API keys and security settings +- Each project is either resource-based or usage-based (see below) + +You can create multiple projects in the same account, for example one per application or one per environment (production, staging). + +## Resource-based vs usage-based projects + +When creating a project, you choose a billing model: + +**Resource-based** projects give you a fixed allocation of CPU, RAM, and storage. You have full control over the resources available to your instance, and billing is predictable: you pay for what you provision, regardless of traffic. + +**Usage-based** projects scale automatically. Instead of choosing a resource tier, you pay based on the number of searches performed and documents indexed. Meilisearch Cloud provisions the resources needed to serve your workload without you managing capacity. This model is simpler to get started with, but costs are harder to predict since they vary with your usage. + +| | Resource-based | Usage-based | +|---|---|---| +| Billing | Fixed resources (CPU, RAM, storage) | Searches and documents | +| Scaling | Manual (you choose the tier) | Automatic | +| Price predictability | High | Depends on traffic | +| Best for | Production workloads with known traffic | Variable or early-stage workloads | + +## Regions + +Meilisearch Cloud is available in multiple regions across the world. Choose the region closest to your users for the lowest latency. + +| Code | Location | Recommended for | +|------|----------|----------------| +| `FRA` | Frankfurt, Germany | European users | +| `LON` | London, United Kingdom | UK and Western Europe | +| `SGP` | Singapore | Southeast Asia and Oceania | +| `JPN` | Japan | Japan and Northeast Asia | +| `SFO` | San Francisco, United States | US West Coast | +| `NYC` | New York, United States | US East Coast and global default | + +## Resource tiers + +Each project runs on a resource tier that defines its CPU, RAM, and storage allocation. Choose a tier based on: + +- **Index size**: Larger indexes require more RAM for fast search +- **Query volume**: High QPS benefits from more CPU +- **Vector search**: Storing and searching vectors requires additional RAM proportional to the number of dimensions and documents + +You can change the resource tier at any time from the project settings. + +## Premium Compute + +Premium Compute is a class of dedicated infrastructure available on Enterprise plans. Compared to standard resource tiers, Premium Compute offers: + +- Dedicated physical resources (no shared CPU or memory with other tenants) +- Higher-performance CPUs with better single-thread and multi-thread throughput +- Faster disk I/O for index reads and writes +- Optimized builds tuned for search workloads + +Premium Compute is suited for production workloads with strict latency requirements or very large indexes. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to enable it. + +## Next steps + + + + Step-by-step guide to creating your first project + + + Detailed region reference and latency guidance + + + Scale CPU and RAM to match your workload + + + View and upgrade your Meilisearch version + + + Scale to large datasets with high availability + + + Automatic weekly backups with Enterprise customization options + + diff --git a/capabilities/platform/infrastructure/regions.mdx b/capabilities/platform/infrastructure/regions.mdx new file mode 100644 index 000000000..2d9064152 --- /dev/null +++ b/capabilities/platform/infrastructure/regions.mdx @@ -0,0 +1,37 @@ +--- +title: Cloud regions +description: Reference of all available Meilisearch Cloud regions with location and latency guidance. +--- + +Meilisearch Cloud is available in six regions. Choosing the right region is one of the most impactful decisions for search latency: network round-trip time between your users and the Meilisearch instance is typically the largest contributor to perceived search speed. + +## Available regions + +| Code | Location | Recommended use case | +|------|----------|---------------------| +| `FRA` | Frankfurt, Germany | European users (GDPR-compliant) | +| `LON` | London, United Kingdom | UK and Western Europe | +| `SGP` | Singapore | Southeast Asia, Oceania, and APAC | +| `JPN` | Japan | Japan and Northeast Asia | +| `SFO` | San Francisco, United States | US West Coast and Pacific | +| `NYC` | New York, United States | US East Coast, Latin America, and global default | + +## Choosing a region + +**Minimize latency for your users.** A search that takes 5 ms to execute on the server can feel instant or sluggish depending on whether the user is 10 ms or 200 ms away. Choose the region closest to the majority of your users. + +**Consider data residency requirements.** If your application handles personal data subject to GDPR or other regional regulations, ensure your project is hosted in a compliant region. `FRA` and `LON` are located within the EU and UK. + +**Plan for multiple regions if you have a global audience.** You can create separate projects per region and route search traffic to the nearest instance from your application layer. Each project is billed independently. + +## Changing a region + +Regions cannot be changed after a project is created. To move to a different region, create a new project in the target region and re-index your documents. + +## Requesting a new region + +The list of available regions grows over time. If none of the current regions fit your requirements (latency, data residency, or compliance), contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to request a new one. + +## Multi-region replication + +For Enterprise workloads that require data to be replicated across multiple regions (for disaster recovery, global low-latency search, or compliance), Meilisearch supports multi-region replication. This is an Enterprise feature that requires dedicated infrastructure setup. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to discuss your requirements. diff --git a/capabilities/platform/infrastructure/sharding_and_replication.mdx b/capabilities/platform/infrastructure/sharding_and_replication.mdx new file mode 100644 index 000000000..6eb3577fc --- /dev/null +++ b/capabilities/platform/infrastructure/sharding_and_replication.mdx @@ -0,0 +1,12 @@ +--- +title: Sharding and replication +description: Scale Meilisearch Cloud to large datasets and high availability with sharding and replication, available on Enterprise plans. +--- + +Sharding and replication allow you to scale Meilisearch beyond a single node. + +**Sharding** distributes your data across multiple instances so each one handles a smaller portion of the index, enabling search across datasets that would not fit on a single machine. + +**Replication** keeps copies of your data on multiple nodes, ensuring search stays available even if one node goes down. + +Both features are available on Enterprise plans only. Setup and configuration are handled by the Meilisearch team. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to discuss your requirements. diff --git a/capabilities/platform/infrastructure/version_management.mdx b/capabilities/platform/infrastructure/version_management.mdx new file mode 100644 index 000000000..e4e2b5fc2 --- /dev/null +++ b/capabilities/platform/infrastructure/version_management.mdx @@ -0,0 +1,58 @@ +--- +title: Version management +description: View your Meilisearch version and upgrade to newer releases from the Cloud project settings. +--- + +{/* Screenshots needed on this page: + 1. Version display in project settings (current version, available upgrade) + 2. Upgrade confirmation modal +*/} + +Meilisearch Cloud manages the Meilisearch engine version for each project. You can view the current version and initiate upgrades from the project settings without any manual server operations. + +## Viewing the current version + +Open your project and go to **Project Settings**. The current Meilisearch version is shown in the **General settings** section. When an upgrade is available, an **Update available** badge appears next to the version number. + + + Project settings showing current Meilisearch version with an Update available badge + + +## Upgrading to a newer version + +1. Click **Update available** in the General settings section. +2. Select the target version from the dropdown. The modal also links to the changelog for that version. + + + Update Meilisearch version modal showing version selector, changelog link, and Update button + + +3. Click **Update**. The project status changes to **updating** and the version field shows the in-progress target version. You will receive an email when the update is complete. + + + Project settings showing updating status with Updating to v1.41.0 indicator + + +## What happens during an upgrade + +Search remains available throughout the upgrade. Document indexing is paused until the upgrade completes. The project status shows **updating** in the dashboard until the process completes. You will receive an email notification when the upgrade is finished, regardless of how long it takes. + +For zero-downtime upgrades including indexing, use replication and upgrade node by node. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to set this up as part of an Enterprise plan. + +**From v1.14 onwards**, upgrades no longer use snapshots for migration. The process takes only a few seconds with minimal downtime. For projects on older versions, upgrade duration may be longer depending on index size. + +## Available versions + +Meilisearch releases a new version every week. The Cloud UI always offers the two most recent versions for selection, both when creating a project and when upgrading an existing one. + +If you prefer stability over being on the cutting edge, consider using the second-to-last available version. It has had more time in production before being offered for selection. + +## Staying up to date + +Check the [changelog](/changelog) for release notes on each Meilisearch version. New versions typically bring performance improvements, new features, and bug fixes. + +## Enterprise upgrade management + +Enterprise customers have additional control over their upgrade schedule. The default upgrade window can be customized to fit your release process, and upgrades can be triggered at any time rather than waiting for the standard rollout. Meilisearch can also conduct upgrade reviews with your team beforehand to walk through breaking changes, migration steps, and expected downtime. + +Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to configure a custom upgrade window or schedule an upgrade review. diff --git a/capabilities/platform/management/experimental_features.mdx b/capabilities/platform/management/experimental_features.mdx new file mode 100644 index 000000000..89262b8b7 --- /dev/null +++ b/capabilities/platform/management/experimental_features.mdx @@ -0,0 +1,36 @@ +--- +title: Experimental features +description: Enable or disable experimental Meilisearch features from the Cloud project settings. +--- + +Meilisearch occasionally ships features in an experimental state before promoting them to stable. Experimental features are fully functional but their API or behavior may change between Meilisearch versions without a deprecation period. Be careful when enabling them in production environments. + +You can enable or disable experimental features per project from **Project Settings > General**. + + + Experimental features section in Project Settings showing checkboxes for each available feature + + +Check the box next to a feature to enable it. Changes take effect immediately without a restart or re-index. + +## Available features + +The list of available features evolves with each Meilisearch release and is not fixed. The features shown in the Cloud UI at any given time depend on your project's current Meilisearch version. As an example, the current UI shows: + +| Feature | Description | +|---------|-------------| +| **Edit documents by function** | Apply custom transformations to documents using Rhai scripts, from simple formatting changes to complex logic | +| **"CONTAINS" and "STARTS_WITH" filters** | Adds the `CONTAINS` filter operator to filter documents where an attribute includes a specific substring | +| **Dynamic Search Rules** | Enable rules that change how search results are ordered when specific conditions are met (e.g. pinning) | +| **Composite embedders** | Use different embedders at search time and indexing time | +| **Multi-modal search** | Index and search through images, text, and other formats in documents | + +For a complete and up-to-date list, see the [experimental features API reference](/reference/api/experimental-features/list-experimental-features) and the [changelog](/changelog). + +## Enterprise-only experimental features + +Some experimental features are not accessible through the Cloud UI and require direct activation by the Meilisearch team. If you need access to a feature that is not listed in your project settings, contact [support@meilisearch.com](mailto:support@meilisearch.com) or reach out to [sales@meilisearch.com](mailto:sales@meilisearch.com) for Enterprise plans. + +## Stability notice + +Experimental features are not covered by the standard API stability guarantee. If you rely on one in production, monitor the [changelog](/changelog) for changes or promotion to stable. diff --git a/capabilities/platform/management/overview.mdx b/capabilities/platform/management/overview.mdx new file mode 100644 index 000000000..5d99d70df --- /dev/null +++ b/capabilities/platform/management/overview.mdx @@ -0,0 +1,25 @@ +--- +title: Project management +sidebarTitle: Overview +description: Configure webhooks and manage experimental features for your Meilisearch Cloud projects. +--- + +Project management features let you integrate Meilisearch Cloud into your broader infrastructure and opt into features that are not yet stable for general availability. + +## Management features + +| Feature | What it does | +|---------|-------------| +| **Webhooks** | Notify an external URL when indexing tasks complete or fail | +| **Experimental features** | Enable or disable features that are not yet stable | + +## Next steps + + + + Configure HTTP callbacks for task completion events + + + Enable experimental Meilisearch features from the Cloud UI + + diff --git a/capabilities/platform/management/webhooks.mdx b/capabilities/platform/management/webhooks.mdx new file mode 100644 index 000000000..20681ee18 --- /dev/null +++ b/capabilities/platform/management/webhooks.mdx @@ -0,0 +1,62 @@ +--- +title: Webhooks +description: Configure HTTP webhooks to receive notifications when Meilisearch indexing tasks complete or fail. +--- + +Webhooks let Meilisearch notify an external HTTP endpoint whenever a task completes. Use them to trigger downstream actions automatically, such as purging a cache after a successful index update or alerting your team when a task fails. + +Webhooks are configured per project in **Project Settings > Webhooks**. Up to 20 webhooks can be configured per project. + + + Webhooks section in Project Settings showing the Add webhook button and description + + +## Adding a webhook + +1. Go to **Project Settings > Webhooks** and click **+ Add webhook**. + + + Add webhook modal with Webhook URL and Authorization Header fields + + +2. Enter the **Webhook URL**: the endpoint where Meilisearch will send POST requests with task data. +3. Optionally, enter an **Authorization Header** (e.g. `Bearer your-secret-token`). This header is sent with every webhook request so your endpoint can verify the source. +4. Click **Add webhook**. + +## How webhooks work + +When a task completes, Meilisearch sends an HTTP POST request to your configured URL. The request body is [ndjson](https://ndjson.org/) (newline-delimited JSON), with one task object per line matching the format returned by the [Tasks API](/reference/api/tasks/get-task). + +``` +{"uid":1,"indexUid":"movies","status":"succeeded","type":"documentAdditionOrUpdate",...} +{"uid":2,"indexUid":"movies","status":"failed","type":"documentAdditionOrUpdate",...} +``` + +Your endpoint must respond with a 2xx status code. Non-2xx responses are treated as failures and retried with exponential backoff. + + + Multiple active webhooks may impact performance. Keep only the webhooks you actively use. + + +## Securing your endpoint + +Always validate the `Authorization` header on incoming webhook requests. Set a long random secret and reject requests that do not match. + +```js +app.post('/webhook', (req, res) => { + if (req.headers['authorization'] !== process.env.WEBHOOK_SECRET) { + return res.status(401).end(); + } + // Process the ndjson payload + res.status(200).end(); +}); +``` + +## Example use cases + +| Use case | Description | +|----------|-------------| +| **Cache purge** | Invalidate your CDN or application cache after a `documentAdditionOrUpdate` task succeeds | +| **Slack notification** | Send a message to a Slack channel when any task fails | +| **CI/CD integration** | Signal a deployment pipeline that a new index is ready | +| **Audit log** | Append every task event to an external log store for compliance | diff --git a/capabilities/platform/monitoring/indexing_performance.mdx b/capabilities/platform/monitoring/indexing_performance.mdx new file mode 100644 index 000000000..143ce8b40 --- /dev/null +++ b/capabilities/platform/monitoring/indexing_performance.mdx @@ -0,0 +1,113 @@ +--- +title: Indexing performance +description: Track indexing latency and debug individual batch performance for your Meilisearch Cloud project. +--- + +{/* Screenshots needed on this page: + 1. Indexing latency (TTS) chart showing p75/p90/p95/p99 in ms — media_LHhV4Ero7U +*/} + +The indexing performance section of the monitoring dashboard shows how quickly Meilisearch processes indexing tasks. It is labeled **Beta** in the Cloud UI. + +You can filter all charts by index using the **All indexes** dropdown, set a date range, or enable real-time mode. Timestamps are displayed in UTC. + +## Indexing latency (TTS) + +The indexing latency chart tracks **time-to-search (TTS)**: the time from when an indexing task is enqueued to when the indexed documents become searchable. Latency is shown at four percentiles, measured in milliseconds: **p75**, **p90**, **p95**, and **p99**. + + + Indexing latency TTS chart showing p75, p90, p95, and p99 times in milliseconds over time + + +| Percentile | What it means | +|------------|--------------| +| **p75** | 75% of indexing tasks completed within this time | +| **p90** | 90% of indexing tasks completed within this time | +| **p95** | 95% of indexing tasks completed within this time | +| **p99** | 99% of indexing tasks completed within this time — the slowest tasks | + +TTS is the metric that matters most for use cases where freshness is important, such as e-commerce catalog updates or live content indexing. + +## Batches + +The **Batches** tab gives you a per-batch view of every indexing operation, along with a detailed trace of where time was spent. Use it when the TTS chart shows high latency and you need to identify the bottleneck. + + + Batches tab showing a list of processed batches with their status, index, batch ID, duration, and start time + + +Each row shows: +- **Status**: succeeded, failed, or in progress +- **Index id**: which index was written to +- **Batch id**: unique identifier for the batch +- **Duration**: total wall-clock time for the batch +- **Started date**: when the batch began processing + +Click a batch to open its detail panel on the right, or use the eye icon to open the full JSON view. + +### Progress trace + +The detail panel includes a `progressTrace` object with timing for every internal step of the indexing pipeline: + + + Batch detail JSON panel showing progressTrace with per-step timing, internalDatabaseSizes, embedderRequests, and writeChannelCongestion + + +Key steps visible in the trace: + +| Trace path | What it measures | +|------------|-----------------| +| `processing tasks > retrieving config` | Loading index configuration | +| `processing tasks > computing document changes` | Diff between incoming and existing documents | +| `processing tasks > reading payload stats` | Parsing incoming document payloads | +| `processing tasks > indexing > extracting documents` | Extracting fields from documents | +| `processing tasks > indexing > extracting facets` | Building facet data | +| `processing tasks > indexing > merging facets` | Merging facet updates into the index | +| `processing tasks > indexing > extracting words` | Tokenizing document content | +| `processing tasks > indexing > merging words` | Merging word data into the inverted index | +| `processing tasks > indexing > writing embeddings to database` | Persisting vector embeddings | +| `processing tasks > indexing > post processing facets` | Finalizing facet search structures | +| `processing tasks > indexing > post processing words` | Finalizing word prefix structures | +| `processing tasks > indexing > building geo json` | Building geo search structures | +| `processing tasks > indexing > finalizing` | Committing the batch to disk | +| `writing tasks to disk` | Persisting the task record | + +### Internal database sizes + +The `internalDatabaseSizes` field shows the current on-disk size of each internal data structure, along with the delta from this batch: + +| Field | What it stores | +|-------|---------------| +| `wordPrefixPositionDocids` | Word prefix position data for prefix search | +| `fieldIdDocidFacetStrings` | Facet string data for filtering and faceting | +| `vectorStore` | Vector embeddings for semantic/hybrid search | +| `documents` | Raw document storage | + +The delta (shown as `+N KiB` or `+N MiB`) tells you how much space each batch adds. A `vectorStore` growing much faster than `documents` indicates a high-dimensional embedding model. + +### Other fields + +| Field | What it shows | +|-------|--------------| +| `embedderRequests.total` | Number of embedding API calls made during this batch | +| `embedderRequests.failed` | Failed embedding calls (non-zero means some documents may not be indexed for vector search) | +| `writeChannelCongestion.attempts` | Number of write attempts | +| `writeChannelCongestion.blocking_attempts` | Write attempts that had to wait (high values indicate write pressure) | + +## Expert support for Enterprise customers + +In most cases, the simplest way to improve indexing performance is to upgrade to a larger resource tier. More RAM and CPU directly reduce indexing time and TTS. You can change your resource tier at any time from the [project settings](/capabilities/platform/infrastructure/manage_resources). + +If upgrading does not resolve the issue, the Meilisearch team can help. Enterprise customers have direct access to experts who can analyze your batch traces, database sizes, and index configuration to optimize for your specific workload. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to learn more. + +## Common issues and fixes + +| Symptom | Likely cause | Fix | +|---------|-------------|-----| +| High TTS across all percentiles | Large document batches or many indexed attributes | Reduce batch size, or reduce the number of `filterableAttributes` and `sortableAttributes` | +| `merging words` step slow | Large inverted index update | Reduce the number of `searchableAttributes` or batch size | +| `writing embeddings to database` slow | High vector dimensions or large batch | Reduce batch size; consider a lower-dimension model | +| `embedderRequests.failed` non-zero | Embedder API errors or rate limits | Check your embedder configuration and API key validity | +| High `writeChannelCongestion.blocking_attempts` | Concurrent write contention | Avoid concurrent indexing operations on the same index | +| TTS spikes periodically | Scheduled bulk imports competing with search | Stagger indexing operations to off-peak hours | +| `vectorStore` growing faster than expected | High embedding dimensions | Switch to a lower-dimension embedding model | diff --git a/capabilities/platform/monitoring/overview.mdx b/capabilities/platform/monitoring/overview.mdx new file mode 100644 index 000000000..d258e43a6 --- /dev/null +++ b/capabilities/platform/monitoring/overview.mdx @@ -0,0 +1,31 @@ +--- +title: Monitoring +sidebarTitle: Overview +description: Monitor search performance, indexing health, and API operations for your Meilisearch Cloud projects. +--- + +Meilisearch Cloud includes built-in monitoring dashboards so you can understand how your project is performing and catch issues before they affect users. Monitoring is currently in **Beta**. + +The dashboard is organized into three sections: + +| Section | What it covers | +|---------|---------------| +| **Search performance** | Search latency (p75/p90/p95/p99) and maximum queries per second | +| **Operations** | Bandwidth (In/Out) and API call volume (Failed/Successful) | +| **Indexing performance** | Indexing latency TTS (p75/p90/p95/p99) | + +All charts support filtering by index, custom date ranges, and a real-time mode. Timestamps are displayed in UTC. + +## Next steps + + + + Monitor search latency percentiles and query throughput + + + Track bandwidth and API call activity + + + Track time-to-search (TTS) for indexing tasks + + diff --git a/capabilities/platform/monitoring/search_performance.mdx b/capabilities/platform/monitoring/search_performance.mdx new file mode 100644 index 000000000..634240516 --- /dev/null +++ b/capabilities/platform/monitoring/search_performance.mdx @@ -0,0 +1,87 @@ +--- +title: Search performance +description: Monitor search latency percentiles, query throughput, and per-step search timing for your Meilisearch Cloud project. +--- + +{/* Screenshots needed on this page: + 1. Search latency chart (p75/p90/p95/p99 in ms) — media_JxXCjcfqpR + 2. Maximum search queries per second chart — media_T1CoksUKsc +*/} + +The search performance section of the monitoring dashboard shows how quickly Meilisearch responds to queries and how much search traffic your project is handling. It is labeled **Beta** in the Cloud UI. + +You can filter all charts by index using the **All indexes** dropdown, set a date range, or enable real-time mode. Timestamps are displayed in UTC. + +## Search latency + +The search latency chart tracks response times at four percentiles: **p75**, **p90**, **p95**, and **p99**, measured in milliseconds. + + + Search latency chart showing p75, p90, p95, and p99 response times in milliseconds over time + + +| Percentile | What it means | +|------------|--------------| +| **p75** | 75% of searches completed within this time | +| **p90** | 90% of searches completed within this time | +| **p95** | 95% of searches completed within this time | +| **p99** | 99% of searches completed within this time — the slowest requests | + +p99 latency is the most important signal for user experience: even rare slow queries are visible to users. A healthy p99 is typically under 100 ms for most workloads. + +## Maximum search queries per second + +This chart shows the peak number of search requests processed per second (q/s) during each time interval. + + + Maximum search queries per second chart + + +Use this chart to: + +- Understand peak traffic patterns across the day or week +- Verify that your resource tier handles your traffic without latency degradation +- Detect unexpected traffic drops that may indicate application errors + +## Performance trace + +Performance trace gives you a per-step breakdown of how time was spent during a search request. Use it to understand exactly where latency comes from, especially when your p99 is high but the cause is not obvious from aggregate metrics. + +To enable it, open the **Search preview** tab for your project and toggle **Performance trace** in the top-right of the results panel. + + + Search preview showing Performance trace panel with per-step timing breakdown including semantic search at 98% of total time + + +The trace shows each step of the search pipeline with its duration and share of total time: + +| Step | What it covers | +|------|---------------| +| **wait for permit** | Time waiting to acquire a read permit (queue wait) | +| **search** | Total time inside the search engine | +| **tokenize** | Query tokenization | +| **resolve universe** | Filter evaluation to compute the candidate document set | +| **keyword search** | Full-text ranking and scoring | +| **embed** | Time to generate the query vector (for hybrid/semantic search) | +| **semantic search** | Vector similarity search against the index | +| **format** | Formatting and serializing the response | + +In the example above, semantic search accounts for 98% of total time (430 ms out of 440 ms). This is expected for hybrid search with a small model, and indicates the bottleneck is the vector search step rather than filtering or ranking. + +## Expert support for Enterprise customers + +In most cases, the simplest way to improve search performance is to upgrade to a larger resource tier. More RAM means more of the index fits in memory, which directly reduces latency. You can change your resource tier at any time from the [project settings](/capabilities/platform/infrastructure/manage_resources). + +If upgrading does not resolve the issue, the Meilisearch team can help. Enterprise customers have direct access to experts who can review your index configuration, query patterns, and performance traces to optimize for your specific workload. Contact [sales@meilisearch.com](mailto:sales@meilisearch.com) to learn more. + +## Common issues and fixes + +| Symptom | Likely cause | Fix | +|---------|-------------|-----| +| High p99, normal p75 | Occasional complex queries or large result sets | Add pagination, reduce `hitsPerPage`, simplify filter expressions | +| All percentiles high | Index too large for available RAM | Upgrade resource plan | +| Latency spike after re-indexing | Settings change triggering re-ranking overhead | Monitor for a few minutes after settings changes; latency typically stabilizes | +| QPS drop without explanation | Application errors or expired API keys | Check application logs and verify API key validity | +| High `embed` time in trace | Slow embedding model or cold model start | Switch to a faster embedder model or use a larger resource tier | +| High `semantic search` time | Large vector index or high vector dimensions | Reduce vector dimensions, or upgrade RAM | +| High `resolve universe` time | Complex filter expressions or many filterable attributes | Simplify filters; avoid filtering on high-cardinality attributes | diff --git a/capabilities/platform/monitoring/usage_metrics.mdx b/capabilities/platform/monitoring/usage_metrics.mdx new file mode 100644 index 000000000..25878897a --- /dev/null +++ b/capabilities/platform/monitoring/usage_metrics.mdx @@ -0,0 +1,43 @@ +--- +title: Operations +description: Monitor bandwidth and API call activity for your Meilisearch Cloud project. +--- + +{/* Screenshots needed on this page: + 1. Bandwidth chart showing In/Out in MB — media_yQbWnbfdrS + 2. API calls chart showing Failed/Successful — media_dv5dHTm4jJ +*/} + +The operations section of the monitoring dashboard shows network activity and API call volume for your project. It is labeled **Beta** in the Cloud UI. + +You can filter all charts by index using the **All indexes** dropdown, set a date range, or enable real-time mode. Timestamps are displayed in UTC. + +## Bandwidth + +The bandwidth chart shows the volume of data transferred in and out of your project, displayed in megabytes (MB). + + + Bandwidth chart showing inbound and outbound data transfer in MB over time + + +- **In**: data sent to Meilisearch (document additions, updates, settings changes) +- **Out**: data returned by Meilisearch (search results, document fetches) + +Outbound bandwidth is typically much higher than inbound for read-heavy workloads. A sudden increase in inbound bandwidth usually corresponds to a large indexing operation. + +## API calls + +The API calls chart shows the number of requests to your project's API, broken down into **Failed** and **Successful** calls. + + + API calls bar chart showing failed and successful requests over time + + +A healthy project should have near-zero failed calls. Common causes of failed API calls: + +| Cause | Fix | +|-------|-----| +| Expired or invalid API key | Rotate the API key in your project settings | +| Malformed request payload | Check your application's request construction | +| Rate limit exceeded | Reduce request frequency or upgrade your plan | +| Index does not exist | Verify the index name in your application | diff --git a/capabilities/platform/overview.mdx b/capabilities/platform/overview.mdx new file mode 100644 index 000000000..b58f47bec --- /dev/null +++ b/capabilities/platform/overview.mdx @@ -0,0 +1,47 @@ +--- +title: Meilisearch Cloud platform +sidebarTitle: Overview +description: Manage your Meilisearch Cloud infrastructure, monitor performance, control billing, and organize your team from a single platform. +--- + +Meilisearch Cloud is the managed hosting platform for Meilisearch. It takes care of provisioning, upgrades, and operations so you can focus on building great search experiences. This section covers everything needed to run Meilisearch in production: creating and scaling projects, monitoring health and performance, managing costs, and collaborating with your team. + +## Platform sections + +| Section | What it covers | +|---------|---------------| +| **Infrastructure** | Projects, regions, resource tiers, version upgrades, sharding and replication | +| **Monitoring** | Search and indexing performance metrics, infrastructure usage | +| **Billing** | Pricing model, invoices, payment methods | +| **Security** | API keys, tenant tokens, multi-tenancy | +| **Teams** | Members, roles, SSO | +| **Management** | Webhooks, experimental features | + +## Key concepts + +**Projects** are the core unit of Meilisearch Cloud. Each project is an isolated Meilisearch instance with its own indexes, API keys, settings, and billing. You can create as many projects as you need, across different regions or resource tiers. + +**Teams** let you invite collaborators and assign them roles. Adding team members has no direct cost impact. Billing is based on your projects: what you pay depends on the resources allocated to each project (CPU, RAM) and the volume of searches and documents they handle. + +## Next steps + + + + Create projects, choose regions, and manage resource tiers + + + Track search performance, indexing health, and infrastructure usage + + + Understand pricing, view invoices, and manage payment methods + + + Secure your data with API keys and tenant tokens + + + Invite collaborators and manage roles + + + Configure webhooks and enable experimental features + + diff --git a/capabilities/teams/getting_started.mdx b/capabilities/platform/teams/getting_started.mdx similarity index 87% rename from capabilities/teams/getting_started.mdx rename to capabilities/platform/teams/getting_started.mdx index d834d098b..3e7a88fd7 100644 --- a/capabilities/teams/getting_started.mdx +++ b/capabilities/platform/teams/getting_started.mdx @@ -36,17 +36,17 @@ Meilisearch Cloud has two team roles: | Role | Description | |------|-------------| | **Owner** | Full access to all projects, billing, team management, and settings. Can invite and remove members, change roles, and delete projects. | -| **Member** | Can view projects and perform searches. Has limited access to project settings and cannot manage billing or team membership. See [manage API keys](/capabilities/security/how_to/manage_api_keys) for key-level access control. | +| **Member** | Can view projects and perform searches. Has limited access to project settings and cannot manage billing or team membership. See [manage API keys](/capabilities/platform/security/how_to/manage_api_keys) for key-level access control. | A team may only have one owner. If you need to transfer ownership, the current owner must explicitly reassign it from the team settings page. ## Next steps - + Learn more about how teams work in Meilisearch Cloud - + Change member roles and understand role permissions in detail diff --git a/capabilities/teams/how_to/configure_sso_for_team.mdx b/capabilities/platform/teams/how_to/configure_sso_for_team.mdx similarity index 88% rename from capabilities/teams/how_to/configure_sso_for_team.mdx rename to capabilities/platform/teams/how_to/configure_sso_for_team.mdx index 70bd233e4..8836fbefc 100644 --- a/capabilities/teams/how_to/configure_sso_for_team.mdx +++ b/capabilities/platform/teams/how_to/configure_sso_for_team.mdx @@ -4,7 +4,7 @@ sidebarTitle: Configure SSO description: Set up Single Sign-On for Meilisearch Cloud to authenticate team members through your identity provider. --- -Single Sign-On (SSO) allows your [team](/capabilities/teams/overview) members to log into Meilisearch Cloud using your organization's existing identity provider (IdP). Instead of managing separate Meilisearch credentials, users authenticate through a centralized system like Okta, Azure AD, or Google Workspace. +Single Sign-On (SSO) allows your [team](/capabilities/platform/teams/overview) members to log into Meilisearch Cloud using your organization's existing identity provider (IdP). Instead of managing separate Meilisearch credentials, users authenticate through a centralized system like Okta, Azure AD, or Google Workspace. SSO is a Meilisearch Cloud enterprise feature. It is not available on self-hosted instances or non-enterprise Cloud plans. @@ -89,10 +89,10 @@ Role assignment (Owner vs. Member) is still managed within the Meilisearch Cloud ## Next steps - + Configure roles and permissions for team members - + Learn more about teams and team management diff --git a/capabilities/teams/how_to/manage_team_roles.mdx b/capabilities/platform/teams/how_to/manage_team_roles.mdx similarity index 88% rename from capabilities/teams/how_to/manage_team_roles.mdx rename to capabilities/platform/teams/how_to/manage_team_roles.mdx index 58cfd6987..3fd47493f 100644 --- a/capabilities/teams/how_to/manage_team_roles.mdx +++ b/capabilities/platform/teams/how_to/manage_team_roles.mdx @@ -26,7 +26,7 @@ Team members have operational access: - View all projects in the team - Perform search queries -- View project settings and [API keys](/capabilities/security/how_to/manage_api_keys) +- View project settings and [API keys](/capabilities/platform/security/how_to/manage_api_keys) - Access project metrics and logs Members cannot modify billing information, delete projects, or manage team membership. @@ -60,10 +60,10 @@ Since there are no costs associated with creating teams, you can freely organize ## Next steps - + Learn more about teams, multiple teams, and team structure - + Enable Single Sign-On for your team diff --git a/capabilities/teams/overview.mdx b/capabilities/platform/teams/overview.mdx similarity index 75% rename from capabilities/teams/overview.mdx rename to capabilities/platform/teams/overview.mdx index a77f91580..9f2ad20ca 100644 --- a/capabilities/teams/overview.mdx +++ b/capabilities/platform/teams/overview.mdx @@ -28,7 +28,7 @@ Meilisearch Cloud billing is based on projects, not teams. There are no costs as |------------|-------|--------| | Access projects and indexes | Yes | Yes | | View project metrics and analytics | Yes | Yes | -| Create and manage [API keys](/capabilities/security/how_to/manage_api_keys) | Yes | Yes | +| Create and manage [API keys](/capabilities/platform/security/how_to/manage_api_keys) | Yes | Yes | | Create projects | Yes | Yes | | Delete projects | Yes | No | | Change billing plan or payment info | Yes | No | @@ -40,18 +40,18 @@ Each team has exactly one owner. If you need to transfer ownership, the current ## SSO integration -Meilisearch Cloud supports Single Sign-On ([SSO](/capabilities/teams/how_to/configure_sso_for_team)) for teams that need centralized authentication. With SSO enabled, team members authenticate through your organization's identity provider (such as Okta, Google Workspace, or Azure AD) instead of managing separate credentials. +Meilisearch Cloud supports Single Sign-On ([SSO](/capabilities/platform/teams/how_to/configure_sso_for_team)) for teams that need centralized authentication. With SSO enabled, team members authenticate through your organization's identity provider (such as Okta, Google Workspace, or Azure AD) instead of managing separate credentials. ## Next steps - + Create your first team and invite members - + Add members, assign roles, and transfer ownership - + Set up Single Sign-On for your team diff --git a/capabilities/security/getting_started.mdx b/capabilities/security/getting_started.mdx index 2c78e61c2..5043d48d0 100644 --- a/capabilities/security/getting_started.mdx +++ b/capabilities/security/getting_started.mdx @@ -12,7 +12,7 @@ There are two steps to use tenant tokens with an official SDK: generating the te ## Generate a tenant token with an official SDK -First, import the SDK. Then create a set of [search rules](/capabilities/security/advanced/tenant_token_payload#search-rules): +First, import the SDK. Then create a set of [search rules](/capabilities/platform/security/advanced/tenant_token_payload#search-rules): @@ -53,16 +53,16 @@ Applications may use tenant tokens and API keys interchangeably when searching. ## Next steps - + Create tenant tokens using JWT libraries instead of Meilisearch SDKs. - + Build tenant tokens manually by assembling the JWT header, payload, and signature. - + Learn about all available fields in the tenant token payload. - + Create, update, and delete API keys for your Meilisearch instance. diff --git a/capabilities/security/how_to/generate_token_from_scratch.mdx b/capabilities/security/how_to/generate_token_from_scratch.mdx index e50894eb4..4bafbd0b7 100644 --- a/capabilities/security/how_to/generate_token_from_scratch.mdx +++ b/capabilities/security/how_to/generate_token_from_scratch.mdx @@ -74,7 +74,7 @@ Lastly, assemble all parts of the payload in a single object: -Consult the [token payload reference](/capabilities/security/advanced/tenant_token_payload) for more information on the requirements for each payload field. +Consult the [token payload reference](/capabilities/platform/security/advanced/tenant_token_payload) for more information on the requirements for each payload field. ## Encode header and payload @@ -89,13 +89,13 @@ After signing the token, you can use it to make search queries in the same way y ## Next steps - + Detailed reference for all fields in the tenant token payload. - + Use a Meilisearch SDK to generate tenant tokens with less manual work. - + Create tenant tokens using JWT libraries like jsonwebtoken. diff --git a/capabilities/security/how_to/generate_token_third_party.mdx b/capabilities/security/how_to/generate_token_third_party.mdx index 9497cf715..db268cd76 100644 --- a/capabilities/security/how_to/generate_token_third_party.mdx +++ b/capabilities/security/how_to/generate_token_third_party.mdx @@ -87,13 +87,13 @@ After signing the token, you can use it to make search queries in the same way y ## Next steps - + Detailed reference for all fields in the tenant token payload. - + Use a Meilisearch SDK to generate tenant tokens with less manual work. - + Build tenant tokens manually by assembling the JWT header, payload, and signature. diff --git a/capabilities/security/how_to/manage_api_keys.mdx b/capabilities/security/how_to/manage_api_keys.mdx index 3611a64f1..ab5158da2 100644 --- a/capabilities/security/how_to/manage_api_keys.mdx +++ b/capabilities/security/how_to/manage_api_keys.mdx @@ -4,7 +4,7 @@ sidebarTitle: Manage API keys description: Create, rotate, and scope API keys to control access to your Meilisearch instance. --- -API keys control who can access your Meilisearch instance and what actions they can perform. Each key has specific permissions and can be scoped to specific indexes. For multi-tenant scenarios, consider using [tenant tokens](/capabilities/security/overview) to restrict search results per user. +API keys control who can access your Meilisearch instance and what actions they can perform. Each key has specific permissions and can be scoped to specific indexes. For multi-tenant scenarios, consider using [tenant tokens](/capabilities/platform/security/overview) to restrict search results per user. ## API key types @@ -192,7 +192,7 @@ Set `expiresAt` to a date in the near future (for example, 90 days) and schedule ## Next steps - + Learn about tenant tokens and multi-tenancy diff --git a/docs.json b/docs.json index c94ddebb1..b54dcb170 100644 --- a/docs.json +++ b/docs.json @@ -484,15 +484,59 @@ ] }, { - "group": "Teams", + "group": "Platform", "pages": [ - "capabilities/teams/overview", - "capabilities/teams/getting_started", + "capabilities/platform/overview", { - "group": "How to", + "group": "Infrastructure", + "pages": [ + "capabilities/platform/infrastructure/overview", + "capabilities/platform/infrastructure/create_a_project", + "capabilities/platform/infrastructure/regions", + "capabilities/platform/infrastructure/manage_resources", + "capabilities/platform/infrastructure/version_management", + "capabilities/platform/infrastructure/sharding_and_replication", + "capabilities/platform/infrastructure/backups" + ] + }, + { + "group": "Monitoring", + "pages": [ + "capabilities/platform/monitoring/overview", + "capabilities/platform/monitoring/search_performance", + "capabilities/platform/monitoring/indexing_performance", + "capabilities/platform/monitoring/usage_metrics" + ] + }, + { + "group": "Billing", + "pages": [ + "capabilities/platform/billing/overview", + "capabilities/platform/billing/pricing_model", + "capabilities/platform/billing/invoices", + "capabilities/platform/billing/payment_methods" + ] + }, + { + "group": "Teams", "pages": [ - "capabilities/teams/how_to/manage_team_roles", - "capabilities/teams/how_to/configure_sso_for_team" + "capabilities/platform/teams/overview", + "capabilities/platform/teams/getting_started", + { + "group": "How to", + "pages": [ + "capabilities/platform/teams/how_to/manage_team_roles", + "capabilities/platform/teams/how_to/configure_sso_for_team" + ] + } + ] + }, + { + "group": "Management", + "pages": [ + "capabilities/platform/management/overview", + "capabilities/platform/management/webhooks", + "capabilities/platform/management/experimental_features" ] } ] @@ -1897,7 +1941,7 @@ }, { "source": "/learn/teams/teams", - "destination": "/capabilities/teams/overview" + "destination": "/capabilities/platform/teams/overview" }, { "source": "/learn/async/working_with_tasks", @@ -2214,6 +2258,54 @@ { "source": "/reference/api/settings/reset-vectorstore", "destination": "/reference/api/settings/get-embedders" + }, + { + "source": "/capabilities/teams", + "destination": "/capabilities/platform/teams" + }, + { + "source": "/capabilities/teams/overview", + "destination": "/capabilities/platform/teams/overview" + }, + { + "source": "/capabilities/teams/getting_started", + "destination": "/capabilities/platform/teams/getting_started" + }, + { + "source": "/capabilities/teams/how_to/configure_sso_for_team", + "destination": "/capabilities/platform/teams/how_to/configure_sso_for_team" + }, + { + "source": "/capabilities/teams/how_to/manage_team_roles", + "destination": "/capabilities/platform/teams/how_to/manage_team_roles" + }, + { + "source": "/capabilities/platform/security", + "destination": "/capabilities/security/overview" + }, + { + "source": "/capabilities/platform/security/overview", + "destination": "/capabilities/security/overview" + }, + { + "source": "/capabilities/platform/security/getting_started", + "destination": "/capabilities/security/getting_started" + }, + { + "source": "/capabilities/platform/security/how_to/manage_api_keys", + "destination": "/capabilities/security/how_to/manage_api_keys" + }, + { + "source": "/capabilities/platform/security/how_to/generate_token_from_scratch", + "destination": "/capabilities/security/how_to/generate_token_from_scratch" + }, + { + "source": "/capabilities/platform/security/how_to/generate_token_third_party", + "destination": "/capabilities/security/how_to/generate_token_third_party" + }, + { + "source": "/capabilities/platform/security/advanced/tenant_token_payload", + "destination": "/capabilities/security/advanced/tenant_token_payload" } ] } diff --git a/getting_started/features.mdx b/getting_started/features.mdx index 3c6a71b6c..8643d89d5 100644 --- a/getting_started/features.mdx +++ b/getting_started/features.mdx @@ -134,8 +134,8 @@ Protect your data with API keys and multi-tenant access control. | Feature | Description | |---------|-------------| | [API keys](/resources/self_hosting/security/basic_security) | Admin, search, and chat key types for different access levels | -| [Tenant tokens](/capabilities/security/overview) | Secure multi-tenant applications with document-level access control | -| [Search rules](/capabilities/security/advanced/tenant_token_payload) | Restrict which documents users can access | +| [Tenant tokens](/capabilities/platform/security/overview) | Secure multi-tenant applications with document-level access control | +| [Search rules](/capabilities/platform/security/advanced/tenant_token_payload) | Restrict which documents users can access | ### Tasks and monitoring @@ -184,7 +184,7 @@ These features are available exclusively on Meilisearch Cloud. |---------|-------------| | Crawler | Crawl web pages with JS rendering, DocSearch mode, and schema extraction | | [Search preview](/resources/self_hosting/getting_started/search_preview) | Visual search interface with filtering, sorting, and document CRUD | -| [Teams](/capabilities/teams/overview) | Organize projects and members into team workspaces | +| [Teams](/capabilities/platform/teams/overview) | Organize projects and members into team workspaces | | [Enterprise SSO/SCIM](/resources/self_hosting/enterprise_edition) | SAML 2.0 SSO and automated user provisioning | | Autoscale disk | Automatically scale storage as data grows | | Automatic backups | Scheduled backups for data safety | diff --git a/getting_started/frameworks/laravel.mdx b/getting_started/frameworks/laravel.mdx index c43db490d..45005638a 100644 --- a/getting_started/frameworks/laravel.mdx +++ b/getting_started/frameworks/laravel.mdx @@ -184,7 +184,7 @@ You built an example application to demonstrate how to use Meilisearch with Lara This demo application uses the following features: - [Multi-search](/reference/api/multi-search/perform-a-multi-search) (search across multiple indexes) -- [Multi-tenancy](/capabilities/security/overview) +- [Multi-tenancy](/capabilities/platform/security/overview) - [Filtering](/capabilities/filtering_sorting_faceting/getting_started) - [Sorting](/capabilities/filtering_sorting_faceting/how_to/sort_results) diff --git a/resources/self_hosting/security/overview.mdx b/resources/self_hosting/security/overview.mdx index b16df6ae3..27231d265 100644 --- a/resources/self_hosting/security/overview.mdx +++ b/resources/self_hosting/security/overview.mdx @@ -31,7 +31,7 @@ For production self-hosted instances: - [ ] Set the [environment to `production`](/resources/self_hosting/configuration/reference#environment) - [ ] Use HTTPS via a [reverse proxy](/resources/self_hosting/deployment/running_production) or [direct SSL](/resources/self_hosting/security/http2_ssl) - [ ] Use the **search API key** (not the admin key) in front-end applications -- [ ] Consider [tenant tokens](/capabilities/security/overview) for multi-tenant search +- [ ] Consider [tenant tokens](/capabilities/platform/security/overview) for multi-tenant search - [ ] Restrict network access with firewall rules ## Next steps