From 7afe0b83bf4576bdd9f26e40274a4078f884a843 Mon Sep 17 00:00:00 2001
From: Jon Harrell <4829245+jharrell@users.noreply.github.com>
Date: Thu, 15 Feb 2024 08:58:48 -0600
Subject: [PATCH 1/3] add accelerate docs and organize static imports
---
.gitignore | 4 +
.../100-introduction/100-what-is-prisma.mdx | 4 +-
.../800-sql-server/020-sql-server-local.mdx | 2 +-
.../100-prisma-schema/50-introspection.mdx | 4 +-
.../100-queries/055-pagination.mdx | 12 +-
...oy-migrations-from-a-local-environment.mdx | 2 +-
.../03-upgrading-the-prisma-layer.mdx | 2 +-
.../300-accelerate/100-what-is-accelerate.mdx | 29 +++
docs/300-accelerate/200-getting-started.mdx | 193 +++++++++++++++
.../300-accelerate/250-connection-pooling.mdx | 65 +++++
docs/300-accelerate/300-caching.mdx | 104 ++++++++
docs/300-accelerate/400-api-reference.mdx | 121 ++++++++++
docs/300-accelerate/500-limitations.mdx | 33 +++
docs/300-accelerate/550-evaluating.mdx | 228 ++++++++++++++++++
docs/300-accelerate/580-local-development.mdx | 65 +++++
docs/300-accelerate/600-faq.mdx | 99 ++++++++
docs/300-accelerate/700-feedback.mdx | 13 +
docs/300-accelerate/index.mdx | 16 ++
...rate-update-database-connection-string.png | Bin 0 -> 46693 bytes
static/img/accelerate/accelerate.png | Bin 0 -> 253464 bytes
static/img/accelerate/swr.png | Bin 0 -> 151136 bytes
static/img/accelerate/ttl.png | Bin 0 -> 113397 bytes
static/img/accelerate/ttl_and_swr.png | Bin 0 -> 169985 bytes
.../baseline-production-from-local.png | Bin
static/img/{ => orm}/connect-sql-server.png | Bin
static/img/{ => orm}/cursor-1.png | Bin
static/img/{ => orm}/cursor-2.png | Bin
static/img/{ => orm}/cursor-3.png | Bin
static/img/{ => orm}/offset-skip-take.png | Bin
.../prisma-db-pull-generate-schema.png | Bin
.../{ => orm}/prisma-evolve-app-workflow.png | Bin
.../prisma-migrate-development-workflow.png | Bin
32 files changed, 983 insertions(+), 13 deletions(-)
create mode 100644 docs/300-accelerate/100-what-is-accelerate.mdx
create mode 100644 docs/300-accelerate/200-getting-started.mdx
create mode 100644 docs/300-accelerate/250-connection-pooling.mdx
create mode 100644 docs/300-accelerate/300-caching.mdx
create mode 100644 docs/300-accelerate/400-api-reference.mdx
create mode 100644 docs/300-accelerate/500-limitations.mdx
create mode 100644 docs/300-accelerate/550-evaluating.mdx
create mode 100644 docs/300-accelerate/580-local-development.mdx
create mode 100644 docs/300-accelerate/600-faq.mdx
create mode 100644 docs/300-accelerate/700-feedback.mdx
create mode 100644 docs/300-accelerate/index.mdx
create mode 100644 static/img/accelerate/accelerate-update-database-connection-string.png
create mode 100644 static/img/accelerate/accelerate.png
create mode 100644 static/img/accelerate/swr.png
create mode 100644 static/img/accelerate/ttl.png
create mode 100644 static/img/accelerate/ttl_and_swr.png
rename static/img/{ => orm}/baseline-production-from-local.png (100%)
rename static/img/{ => orm}/connect-sql-server.png (100%)
rename static/img/{ => orm}/cursor-1.png (100%)
rename static/img/{ => orm}/cursor-2.png (100%)
rename static/img/{ => orm}/cursor-3.png (100%)
rename static/img/{ => orm}/offset-skip-take.png (100%)
rename static/img/{ => orm}/prisma-db-pull-generate-schema.png (100%)
rename static/img/{ => orm}/prisma-evolve-app-workflow.png (100%)
rename static/img/{ => orm}/prisma-migrate-development-workflow.png (100%)
diff --git a/.gitignore b/.gitignore
index b2d6de3062..494becda23 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,7 @@
npm-debug.log*
yarn-debug.log*
yarn-error.log*
+
+# wrangler project
+.dev.vars
+.wrangler/
\ No newline at end of file
diff --git a/docs/200-orm/050-overview/100-introduction/100-what-is-prisma.mdx b/docs/200-orm/050-overview/100-introduction/100-what-is-prisma.mdx
index dd091d68c0..0a64dd2c0e 100644
--- a/docs/200-orm/050-overview/100-introduction/100-what-is-prisma.mdx
+++ b/docs/200-orm/050-overview/100-introduction/100-what-is-prisma.mdx
@@ -249,7 +249,7 @@ With **Prisma Migrate**, Prisma's integrated database migration tool, the workfl
1. Migrate your development database using the `prisma migrate dev` CLI command
1. Use Prisma Client in your application code to access your database
-
+
To learn more about the Prisma Migrate workflow, see:
@@ -268,6 +268,6 @@ The typical workflow when using **SQL migrations and introspection** is slightly
1. (Re-)generate Prisma Client
1. Use Prisma Client in your application code to access your database
-
+
To learn more about the introspection workflow, please refer the [introspection section](/orm/prisma-schema/introspection).
diff --git a/docs/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx b/docs/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
index f52fd1c524..f2f6dec3e4 100644
--- a/docs/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
+++ b/docs/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
@@ -14,7 +14,7 @@ To run a Microsoft SQL Server locally on a Windows machine:
1. Use Windows Authentication to log in to Microsoft SQL Server Management Studio (expand the **Server Name** dropdown and click **<Browse for more...>** to find your database engine):
-
+
diff --git a/docs/200-orm/100-prisma-schema/50-introspection.mdx b/docs/200-orm/100-prisma-schema/50-introspection.mdx
index 553f50b67f..d52e6b3c79 100644
--- a/docs/200-orm/100-prisma-schema/50-introspection.mdx
+++ b/docs/200-orm/100-prisma-schema/50-introspection.mdx
@@ -18,7 +18,7 @@ However, it can also be [used _repeatedly_ in an application](#introspection-wit
Introspection has one main function: Populate your Prisma schema with a data model that reflects the current database schema.
-
+
Here's an overview of its main functions on SQL databases:
@@ -63,7 +63,7 @@ The typical workflow for projects that are not using Prisma Migrate, but instead
Note that as you evolve the application, [this process can be repeated for an indefinite number of times](#introspection-with-an-existing-schema).
-
+
## Rules and conventions
diff --git a/docs/200-orm/200-prisma-client/100-queries/055-pagination.mdx b/docs/200-orm/200-prisma-client/100-queries/055-pagination.mdx
index 315509255a..aa451ad2e9 100644
--- a/docs/200-orm/200-prisma-client/100-queries/055-pagination.mdx
+++ b/docs/200-orm/200-prisma-client/100-queries/055-pagination.mdx
@@ -21,7 +21,7 @@ const results = await prisma.post.findMany({
})
```
-
+
To implement pages of results, you would just `skip` the number of pages multiplied by the number of results you show per page.
@@ -103,7 +103,7 @@ const firstQueryResults = await prisma.post.findMany({
The following diagram shows the IDs of the first 4 results - or page 1. The cursor for the next query is **29**:
-
+
The second query returns the first 4 `Post` records that contain the word `"Prisma"` **after the supplied cursor** (in other words - IDs that are larger than **29**):
@@ -130,7 +130,7 @@ const myCursor = lastPostInResults.id // Example: 52
The following diagram shows the first 4 `Post` records **after** the record with ID **29**. In this example, the new cursor is **52**:
-
+
### FAQ
@@ -138,15 +138,15 @@ The following diagram shows the first 4 `Post` records **after** the record with
If you do not `skip: 1`, your result set will include your previous cursor. The first query returns four results and the cursor is **29**:
-
+
Without `skip: 1`, the second query returns 4 results after (and _including_) the cursor:
-
+
If you `skip: 1`, the cursor is not included:
-
+
You can choose to `skip: 1` or not depending on the pagination behavior that you want.
diff --git a/docs/200-orm/200-prisma-client/500-deployment/600-deploy-migrations-from-a-local-environment.mdx b/docs/200-orm/200-prisma-client/500-deployment/600-deploy-migrations-from-a-local-environment.mdx
index 8271afb12b..d99c3d8cf2 100644
--- a/docs/200-orm/200-prisma-client/500-deployment/600-deploy-migrations-from-a-local-environment.mdx
+++ b/docs/200-orm/200-prisma-client/500-deployment/600-deploy-migrations-from-a-local-environment.mdx
@@ -51,4 +51,4 @@ The pipeline should handle deployment to staging and production environments, an
When you add Prisma Migrate to an **existing database**, you must [baseline](/orm/prisma-migrate/workflows/baselining) the production database. Baselining is performed **once**, and can be done from a local instance.
-
+
diff --git a/docs/200-orm/800-more/300-upgrade-guides/800-upgrade-from-prisma-1/03-upgrading-the-prisma-layer.mdx b/docs/200-orm/800-more/300-upgrade-guides/800-upgrade-from-prisma-1/03-upgrading-the-prisma-layer.mdx
index 314eadff69..f939728df1 100644
--- a/docs/200-orm/800-more/300-upgrade-guides/800-upgrade-from-prisma-1/03-upgrading-the-prisma-layer.mdx
+++ b/docs/200-orm/800-more/300-upgrade-guides/800-upgrade-from-prisma-1/03-upgrading-the-prisma-layer.mdx
@@ -419,7 +419,7 @@ npx prisma db pull
Here's a graphical illustration for what happens when `db pull` is invoked:
-
+
For the above Prisma 1 datamodel, this results in the following Prisma 2 schema (note that the models have been reordered to match the initial order of the Prisma 1 datamodel):
diff --git a/docs/300-accelerate/100-what-is-accelerate.mdx b/docs/300-accelerate/100-what-is-accelerate.mdx
new file mode 100644
index 0000000000..f18880b9d0
--- /dev/null
+++ b/docs/300-accelerate/100-what-is-accelerate.mdx
@@ -0,0 +1,29 @@
+---
+title: 'What is Accelerate'
+metaTitle: 'What is Accelerate'
+metaDescription: 'Learn about Accelerate, a global cache and serverless connection pool that makes your database queries faster.'
+tocDepth: 3
+toc: true
+---
+
+
+
+[Accelerate](https://www.prisma.io/data-platform/accelerate) is a global database cache available in 300 locations that you can use to achieve up to 1000x faster database queries.
+
+Its main features are:
+
+- a global cache
+- scalable connection pool for serverless and edge applications
+- usage of Prisma Client at the edge (e.g. in Cloudflare Workers or Vercel Edge Functions)
+
+The goal of Accelerate is to improve response times and reduce database load. It works by caching data at the edge using established caching patterns that you control.
+
+While Accelerate is beneficial for all types of applications, being at the edge provides additional benefits to edge function environments like [Vercel Edge Functions](https://vercel.com/docs/concepts/functions/edge-functions), [Cloudflare Workers](https://workers.cloudflare.com/), and [Deno Deploy](https://deno.com/deploy). Cache hits can be served from data centers near the user regardless of the region of the database.
+
+
+
+## See Accelerate in action
+
+We built a small sample application, [Accelerate Speed Test](https://accelerate-speed-test.prisma.io/). The app compares the performance of cached and uncached queries side by side. The app is [open source](https://github.com/prisma/accelerate-speed-test) and you can clone it to try it yourself.
+
+
diff --git a/docs/300-accelerate/200-getting-started.mdx b/docs/300-accelerate/200-getting-started.mdx
new file mode 100644
index 0000000000..d7071ce236
--- /dev/null
+++ b/docs/300-accelerate/200-getting-started.mdx
@@ -0,0 +1,193 @@
+---
+title: 'Getting started'
+metaTitle: 'Getting started with Accelerate'
+metaDescription: 'Learn how to get up and running with Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+
+
+
+
+## Prerequisites
+
+To get started with Accelerate, you will need the following:
+
+- A GitHub account.
+- A project that uses [Prisma Client](/orm/prisma-client) `4.16.1` or higher. If your project is using interactive transactions, you need to use `5.1.1` or higher. (We always recommend using the latest version of Prisma.)
+- A hosted PostgreSQL, MySQL, PlanetScale, CockroachDB, or MongoDB database.
+
+## 1. Enable Accelerate in a project
+
+In order to enable Accelerate, you can log in to [Prisma Data Platform](https://pris.ly/pdp) and create a new project. Follow the instructions in the UI to add Accelerate.
+
+At the end of the setup process, you'll obtain a connection string that connects to Accelerate. This connection string also contains an API key that you need to use when configuring Prisma Client to use Accelerate.
+
+## 2. Use Accelerate in your application
+
+To get started using Accelerate, we recommend using the [latest version of Prisma ORM](https://github.com/prisma/prisma/releases/).
+
+### 2.1. Update your database connection string
+
+After enabling Accelerate in your project and creating a new API key, you should be given an Accelerate connection string.
+
+To use this connection string, update the `datasource` block's `url` field in your Prisma schema:
+
+```prisma
+datasource db {
+ provider = "postgresql"
+ url = env("DATABASE_URL")
+}
+```
+
+Most likely, as shown above, your database connection string in defined in a `.env` file rather than hard-coded into the schema file.
+
+Update that variable to use the new Accelerate connection string:
+
+```env file=.env
+# __API_KEY__ is a unique API key that Accelerate generates and automatically assigns to a project.
+DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=__API_KEY__"
+
+# Previous connection string
+# DATABASE_URL="postgresql://user:password@host:port/db_name?schema=public"
+```
+
+Prisma Migrate and Introspection do not work with a `prisma://` connection string. In order to continue using these features add a new variable to the `.env` file named `DIRECT_DATABASE_URL` whose value is the direct database connection string:
+
+
+
+As of Prisma version `5.2.0` you can use Prisma Studio with the Accelerate connection string.
+
+
+
+```env file=.env highlight=3;add
+DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=__API_KEY__"
+DIRECT_DATABASE_URL="postgresql://user:password@host:port/db_name?schema=public"
+```
+
+Then in your Prisma schema's `datasource` block add a field named `directUrl` with the following:
+
+```prisma highlight=4;add
+datasource db {
+ provider = "postgresql"
+ url = env("DATABASE_URL")
+ directUrl = env("DIRECT_DATABASE_URL")
+}
+```
+
+Migrations and introspections will use the `directUrl` connection string rather than the one defined in `url` when this configuration is provided.
+
+> `directUrl` is useful for you to carry out migrations and introspections. However, you don't need `directUrl` to use Accelerate in your application.
+
+### 2.2. Install the Accelerate Prisma Client extension
+
+Run the following command to install the Accelerate extension for Prisma Client:
+
+```terminal
+npm install @prisma/extension-accelerate
+```
+
+### 2.3. Generate Prisma Client for Accelerate
+
+If you're using Prisma version `5.2.0` or greater, Prisma Client will automatically determine how it should connect to the database depending on the protocol in the database connection string. If the connection string in the `DATABASE_URL` starts with `prisma://`, Prisma Client will try to connect to your database using Prisma Accelerate.
+
+When using Prisma Accelerate in long-running application servers, such as a server deployed on AWS EC2, you can generate the Prisma Client by executing the following command:
+
+```terminal
+npx prisma generate
+```
+
+When using Prisma Accelerate in a Serverless or an Edge application, we recommend you to run the following command to generate Prisma Client:
+
+```terminal
+npx prisma generate --no-engine
+```
+
+
+
+The `--no-engine` flag prevents a Query Engine file from being included in the generated Prisma Client, this ensures the bundle size of your application remains small.
+
+
+
+
+
+If your Prisma version is below `5.2.0`, generate Prisma Client with the `--accelerate` option:
+
+```terminal
+npx prisma generate --accelerate
+```
+
+If your Prisma version is below `5.0.0`, generate Prisma Client with the `--data-proxy` option:
+
+
+### 2.4. Extend your Prisma Client instance to add the Accelerate extension
+
+To use Accelerate, you must extend Prisma Client with the Accelerate extension.
+Extend your Prisma Client instance to add the Accelerate extension:
+
+```ts
+import { PrismaClient } from '@prisma/client'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+```
+
+If you are going to deploy to an edge runtime (like Cloudflare Workers, Vercel Edge Functions, Deno Deploy, or Netlify Edge Functions), use our edge client instead:
+
+```ts
+import { PrismaClient } from '@prisma/client/edge'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+```
+
+If VS Code does not recognize the `$extends` method, refer to [this section](/accelerate/faq#vs-code-does-not-recognize-the-extends-method) on how to resolve the issue.
+
+
+
+If you are using [Prisma Middleware](/orm/prisma-client/client-extensions/middleware) in your application, make sure they are added before any Prisma Client extensions (like Accelerate). For example:
+
+```ts
+const prisma = new PrismaClient().$use(middleware).$extends(withAccelerate())
+```
+
+
+
+### 2.5. Use Accelerate in your database queries
+
+The `withAccelerate` extension primarily does two things:
+
+- Gives you access to the `cacheStrategy` field within each applicable model method that allows you to define a cache strategy per-query.
+- Routes all of your queries through a connection pooler.
+
+#### No cache strategy to only use connection pool
+
+If you simply want to take advantage of Accelerate's connection pooling feature without applying a cache strategy, you may run your query the same way you would have without Accelerate.
+
+By enabling Accelerate and supplying the Accelerate connection string, your queries now use the connection pooler by default.
+
+#### Define a cache strategy
+
+Update a query with the new `cacheStrategy` property which allows you to define a cache strategy for that specific query:
+
+```ts
+const user = await prisma.user.findMany({
+ where: {
+ email: {
+ contains: 'alice@prisma.io',
+ },
+ },
+ cacheStrategy: { swr: 60, ttl: 60 },
+})
+```
+
+In the example above, `swr: 60` and `ttl: 60` means Accelerate will serve cached data for 60 seconds and then another 60 seconds while Accelerate fetches fresh data in the background.
+
+You should now see improved performance for your cached queries.
+
+
+
+For information about which strategy best serves your application, see [Select a cache strategy](/accelerate/caching#selecting-a-cache-strategy).
+
+
diff --git a/docs/300-accelerate/250-connection-pooling.mdx b/docs/300-accelerate/250-connection-pooling.mdx
new file mode 100644
index 0000000000..007dde554f
--- /dev/null
+++ b/docs/300-accelerate/250-connection-pooling.mdx
@@ -0,0 +1,65 @@
+---
+title: 'Connection Pooling'
+metaTitle: 'Accelerate: Connection Pooling'
+metaDescription: "Learn about everything you need to know to use Accelerate's connection pooling."
+---
+
+## Connection pooling
+
+A [connection pool](https://en.wikipedia.org/wiki/Connection_pool#:~:text=In%20software%20engineering%2C%20a%20connection,executing%20commands%20on%20a%20database.) is a storage of database connections that can be reused for future requests to the database. When a new connection is requested, it is retrieved from the pool if one is available. Once the connection is no longer needed, it is returned to the pool for reuse.
+
+[Connection pooling](https://www.prisma.io/dataguide/database-tools/connection-pooling) is important as it allows you to reuse existing connections instead of creating new ones, which can be an expensive operation.
+
+The efficient management of database connections allows the database to process more queries without exhausting the available database connections, making your application more scalable.
+
+Accelerate provides built-in connection pooling by default. By simply using Accelerate, you get the benefits of connection pooling without having to configure anything. However, you can also configure the connection pool to suit your needs.
+
+
+
+For more information about connection pooling in Prisma, see the documentation [here](/orm/prisma-client/setup-and-configuration/databases-connections/connection-pool).
+
+
+
+### Default connection pool size
+
+By default, Accelerate calculates a default connection pool size using the formula `num_physical_cpus * 2 + 1`.
+
+
+
+For example, a machine with 2 physical CPUs will have a default connection pool size of `2 * 2 + 1` or `5`.
+
+
+
+This means that Accelerate will create a maximum of 5 connections to the database. If more than 5 connections are requested, Accelerate will queue the requests until a connection is available.
+
+### Configuring the connection pool size
+
+The connection pool size can be configured to a value other than the default via the _database connection string_.
+
+
+
+To adjust the connection pool size, you can add the `connection_limit` parameter to the database connection string. The value of `connection_limit` is the maximum number of connections that Accelerate will open against your database.
+
+For example, here is how you can set a connection pool size of 10:
+
+```env no-copy
+postgresql://user:password@localhost:5432/db?connection_limit=10
+```
+
+### Configuring the connection pool timeout
+
+The connection pool timeout is the duration, measured in seconds, during which the query engine must process a specific query; failing to do so within this timeframe results in an exception being thrown, and the system proceeds to the next query in the queue.
+
+Similar to the connection pool size, you may also configure the connection pool timeout via the _database connection string_. To adjust this value, you may add the `pool_timeout` parameter to the database connection string.
+
+For example:
+
+```env no-copy
+postgresql://user:password@localhost:5432/db?connection_limit=10&pool_timeout=20
+```
+
+
+
+The default value for `pool_timeout` is `10` seconds.
+
+
diff --git a/docs/300-accelerate/300-caching.mdx b/docs/300-accelerate/300-caching.mdx
new file mode 100644
index 0000000000..b02f7f9c81
--- /dev/null
+++ b/docs/300-accelerate/300-caching.mdx
@@ -0,0 +1,104 @@
+---
+title: 'Caching'
+metaTitle: 'Accelerate: Caching'
+metaDescription: "Learn everything you need to know to use Accelerate's global database caching."
+---
+
+## Cache strategies
+
+For all read queries in Prisma Client, you can define the `cacheStrategy` parameter that configures cache behavior. The cache strategy allows you to define two main characteristics of the cache:
+
+- **Time-to-live (TTL):** Duration in seconds a cached response is considered _fresh_.
+- **Stale-while-Revalidating (SWR):** Duration in seconds a stale cache response is considered acceptable while the cache is refreshed in the background
+
+## Time-to-live (TTL)
+
+Time-to-Live (TTL) determines how long cached data is considered fresh. By specifying the `ttl` in seconds, you can control the duration for which data in the cache remains valid. When a read query is executed, if the cached response is within the `ttl` limit, Prisma Client retrieves the data from the cache without querying the database. If the cached data is not available or has expired, Prisma Client queries the database and stores the results in the cache for future requests.
+
+Use `ttl` in `cacheStrategy` and specify the TTL of the query in seconds:
+
+```javascript
+await prisma.user.findMany({
+ cacheStrategy: {
++ ttl: 60,
+ },
+});
+```
+
+With a specified TTL of 60 seconds, the majority of requests will result in
+a cache hit throughout the TTL duration:
+
+
+
+TTL is useful for reducing database load and latency for data that does not require frequent updates.
+
+## Stale-While-Revalidate (SWR)
+
+Stale-While-Revalidate (SWR) allows you to control how long Accelerate can serve stale cache data while fetching fresh data in the background. When a read query is executed, Accelerate checks the age of the cached response against the `swr` duration. If the cache data is within the `swr` limit, Accelerate serves the stale data while simultaneously refreshing the cache by fetching the latest data from the database.
+
+Use `swr` in `cacheStrategy` and specify the SWR of the query in seconds:
+
+```javascript
+await prisma.user.findMany({
+ cacheStrategy: {
++ swr: 60,
+ },
+});
+```
+
+When specifying a SWR of 60 seconds, the cache serves stale data until the cache refreshes itself in the background after each request:
+
+
+
+## Selecting a cache strategy
+
+Caching helps you improve query response times and reduce database load. However, it also means you might serve stale data to the client. Whether or not serving stale data is acceptable and to what extent depends on your use case. `ttl` and `swr` are parameters you can use the tweak the cache behavior.
+
+### Cache strategy using TTL
+
+Use TTL to reduce database load when stale cached data is acceptable.
+
+#### Use case: Product catalog in e-commerce applications
+
+Consider an e-commerce application with a product catalog that doesn't frequently change. By setting a `ttl` of, let's say, 1 hour, Prisma Client can serve cached product data for subsequent user requests within that hour without hitting the database. This significantly reduces the database load and improves the response time for product listing pages.
+
+### Cache strategy using SWR
+
+Use SWR to respond quickly to requests with minimal stale data. While it does not reduce database load, it can improve response times significantly.
+
+#### Use case: User profile in social media platforms
+
+Imagine a social media platform where user profiles are frequently accessed. By leveraging `swr` with a duration of, let's say, 5 minutes, Accelerate can serve the cached user profile information quickly, reducing the latency for profile pages. Meanwhile, in the background, it refreshes the cache after every request, ensuring that any updates made to the profile are eventually reflected for subsequent requests.
+
+### Cache strategy using TTL + SWR
+
+For very fast response times and reduced database load, use both TTL and SWR. You can use this strategy to fine-tune your application’s tolerance for stale data.
+
+Use `ttl` and `swr` in `cacheStrategy` and specify the TTL and SWR of the query in seconds:
+
+```javascript
+await prisma.user.findMany({
+ cacheStrategy: {
++ ttl: 30,
++ swr: 60,
+ },
+});
+```
+
+When specifying a TTL of 30 seconds and SWR of 60 seconds, the cache serves fresh data for the initial 30 seconds. Subsequently, it serves stale data until the cache refreshes itself in the background after each request:
+
+
+
+#### Use case: News articles
+
+Consider a news application where articles are frequently accessed but don't require real-time updates. By setting a `ttl` of 2 hours and an `swr` duration of 5 minutes, Prisma Client can serve cached articles quickly, reducing latency for readers. As long as the articles are within the `ttl`, users get fast responses. After the `ttl` expires, Prisma Client serves the stale articles for an additional 5 minutes while fetching the latest news from the database, maintaining a balance between performance and freshness.
+
+## Default cache strategy
+
+Accelerate defaults to **no cache** to avoid counterintuitive issues. Caching can be a powerful tool for improving performance but can also be dangerous if not used correctly.
+
+For example, consider writing a query on a critical path without explicitly defining a cache strategy. If you run the code, you might receive incorrect data without explanation. This could be caused by someone forgetting to disable the default _implicit_ cache behavior. Implicit caching allows these counterintuitive issues to arise, leading to undesirable results.
+
+You must explicitly opt-in to caching if you want to use it. This makes it clear to developers that caching is not enabled by default and helps prevent counterintuitive issues from occurring.
+
+> When no cache strategy is specified or during a cache miss, a Prisma Client with the Accelerate extension routes all queries to the database through a connection pool instance near the database region.
diff --git a/docs/300-accelerate/400-api-reference.mdx b/docs/300-accelerate/400-api-reference.mdx
new file mode 100644
index 0000000000..a78b3d2971
--- /dev/null
+++ b/docs/300-accelerate/400-api-reference.mdx
@@ -0,0 +1,121 @@
+---
+title: 'API Reference'
+metaTitle: 'Accelerate: API Reference'
+metaDescription: 'API reference documentation for Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+
+
+The Accelerate API reference documentation is based on the following schema:
+
+```prisma
+model User {
+ id Int @id @default(autoincrement())
+ name String?
+ email String @unique
+}
+```
+
+All example are based on the `User` model.
+
+
+
+## cacheStrategy
+
+With the Accelerate extension for Prisma Client, you can use the `cacheStrategy` parameter for model queries and use the [`ttl`](/accelerate/caching#time-to-live-ttl) and [`swr`](/accelerate/caching#stale-while-revalidate-swr) parameters to define a cache strategy for Accelerate. The Accelerate extension requires that you install Prisma Client version `4.10.0`.
+
+### Options
+
+The `cacheStrategy` parameter takes an option with the following keys:
+
+| Option | Example | Type | Required | Description |
+| ------ | ------- | ----- | -------- | ------------------------------------------- |
+| `swr` | `60` | `Int` | No | The stale-while-revalidate time in seconds. |
+| `ttl` | `60` | `Int` | No | The time-to-live time in seconds. |
+
+### Examples
+
+Add a caching strategy to a query that defines a 60-second stale-while-revalidate value and 60-second time-to-live value:
+
+```ts highlight=7;normal
+await prisma.user.findMany({
+ where: {
+ email: {
+ contains: 'alice@prisma.io',
+ },
+ },
+ cacheStrategy: { swr: 60, ttl: 60 },
+})
+```
+
+### Supported Prisma Client operations
+
+The following is a list of all read query operations and support `cacheStrategy`:
+
+- [`findUnique`](/orm/reference/prisma-client-reference#findunique)
+- [`findUniqueOrThrow`](/orm/reference/prisma-client-reference#finduniqueorthrow)
+- [`findFirst`](/orm/reference/prisma-client-reference#findfirst)
+- [`findFirstOrThrow`](/orm/reference/prisma-client-reference#findfirstorthrow)
+- [`findMany`](/orm/reference/prisma-client-reference#findmany)
+- [`count`](/orm/reference/prisma-client-reference#count)
+- [`aggregate`](/orm/reference/prisma-client-reference#aggregate)
+- [`groupBy`](/orm/reference/prisma-client-reference#groupby)
+
+
+
+The `cacheStrategy` parameter is not supported on any write operations, such as `create`.
+
+
+
+## withAccelerateInfo
+
+Any query that supports the `cacheStrategy` can append `withAccelerateInfo()` to wrap the response data and include additional information about the Accelerate response.
+
+To retrieve the status of the response, use:
+
+```ts
+const { data, info } = await prisma.user
+ .count({
+ cacheStrategy: { ttl: 60, swr: 600 },
+ where: { myField: 'value' },
+ })
+ .withAccelerateInfo()
+
+console.dir(info)
+```
+
+
+
+Notice the `info` property of the response object. This is where the request information is stored.
+
+
+
+### Return type
+
+The `info` object is of type `AccelerateInfo` and follows the interface below:
+
+```ts
+interface AccelerateInfo {
+ cacheStatus: 'ttl' | 'swr' | 'miss' | 'none'
+ lastModified: Date
+ region: string
+ requestId: string
+ signature: string
+}
+```
+
+| Property | Type | Description |
+| -------------- | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cacheStatus` | "ttl" \| "swr" \| "miss" \| "none" | The cache status of the response.
- `ttl` indicates a cache hit within the `ttl` duration and no database query was executed
- `swr` indicates a cache hit within the `swr` duration and the data is being refreshed by Accelerate in the background
- `miss` indicates that both `ttl` and `swr` have expired and the database query was executed by the request
- `none` indicates that no cache strategy was specified and the database query was executed by the request
|
+| `lastModified` | `Date` | The date the response was last refreshed. |
+| `region` | `String` | The data center region that received the request. |
+| `requestId` | `String` | Unique identifier of the request. Useful for troubleshooting. |
+| `signature` | `String` | The unique signature of the Prisma operation. |
+
+## Errors
+
+Prisma Accelerate-related errors start with `P6xxx`.
+
+You can find the full error code reference for Prisma Accelerate [here](/orm/reference/error-reference#prisma-accelerate).
diff --git a/docs/300-accelerate/500-limitations.mdx b/docs/300-accelerate/500-limitations.mdx
new file mode 100644
index 0000000000..dec1b870a6
--- /dev/null
+++ b/docs/300-accelerate/500-limitations.mdx
@@ -0,0 +1,33 @@
+---
+title: 'Limitations'
+metaTitle: 'Accelerate: Limitations'
+metaDescription: 'Learn about limitations of Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+
+
+Below are descriptions of known limitations when using Accelerate. If you are aware of any limitations that are missing, please let us know on the [#accelerate-feedback](https://prisma.slack.com/archives/C04KTN0V2Q0) channel in our community Slack.
+
+
+
+## Query timeout limit
+
+Accelerate has a global timeout of `10s` for each query. Reach out to [support@prisma.io](mailto:support@prisma.io) with your use case if your application requires a greater timeout value.
+
+## Interactive transactions query timeout limit
+
+Accelerate has a global timeout of `15s` for each [interactive transaction](/orm/prisma-client/queries/transactions#interactive-transactions). Reach out to [support@prisma.io](mailto:support@prisma.io) with your use case if your application requires a greater timeout value.
+
+## Response size limit
+
+Accelerate has a global response size limit of `5MB`. Reach out to [support@prisma.io](mailto:support@prisma.io) with your use case if your application requires a larger response size.
+
+## Cannot cache raw queries
+
+At the moment, it is not possible to cache the responses of [raw queries](/orm/prisma-client/queries/raw-database-access/raw-queries).
+
+## Not compatible with the fluent API
+
+Client Extensions (which are used in Accelerate) currently do not correctly forward the [fluent API](/orm/prisma-client/queries/relation-queries#fluent-api) types. We hope to get a fix into Client Extensions soon.
diff --git a/docs/300-accelerate/550-evaluating.mdx b/docs/300-accelerate/550-evaluating.mdx
new file mode 100644
index 0000000000..dd0dd930db
--- /dev/null
+++ b/docs/300-accelerate/550-evaluating.mdx
@@ -0,0 +1,228 @@
+---
+title: 'Evaluating'
+metaTitle: 'Accelerate: Evaluating'
+metaDescription: 'Learn about evaluating Prisma Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+
+
+Prisma Accelerate optimizes database interactions through advanced connection pooling and global edge caching. Its connection pooler is available in 16 regions and helps applications load-balance and scale database requests based on demand.
+
+Considering the information above, we recommend evaluating Accelerate with high volume to see it perform under load.
+
+
+
+## How Accelerate's connection pool optimizes performance under load
+
+Prisma Accelerate employs a dynamic, serverless connection pooling infrastructure. When a request is made, a connection pool is quickly provisioned for the project in the region assigned while configuring Prisma Accelerate. This connection pool remains active, serving many additional requests while reusing established database connections. The connection pool will disconnect after a period of inactivity, so it’s important to evaluate Prisma Accelerate with a consistent stream of traffic.
+
+**Key Benefits:**
+
+- **Optimized Query Performance:** The serverless connection pooler adapts to the query load, ensuring the database connections are managed efficiently during peak demand.
+
+ > Prisma Accelerate’s connection pooler cannot improve the performance of queries in the database. In scenarios where query performance is an issue, we recommend optimizing the Prisma query, applying indexes, or utilizing Accelerate’s edge caching.
+
+- **Maximize Connection Reuse:** Executing a consistent volume of queries helps maintain active instances of Accelerate connection poolers. This increases connection reuse, ensuring faster response times for subsequent queries.
+
+By understanding and harnessing this mechanism, you can ensure that your database queries perform consistently and efficiently at scale.
+
+## Evaluating Prisma Accelerate connection pooling performance
+
+Below you will find an example of how to evaluate Prisma Accelerate using a sample model:
+
+```prisma
+model Notes {
+ id Int @id @default(autoincrement())
+ title String
+ createdAt DateTime @default(now())
+ updatedAt DateTime? @updatedAt
+}
+```
+
+```typescript
+import { PrismaClient } from '@prisma/client'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+
+function calculateStatistics(numbers: number[]): {
+ average: number
+ p50: number
+ p75: number
+ p99: number
+} {
+ if (numbers.length === 0) {
+ throw new Error('The input array is empty.')
+ }
+
+ // Sort the array in ascending order
+ numbers.sort((a, b) => a - b)
+
+ const sum = numbers.reduce((acc, num) => acc + num, 0)
+ const count = numbers.length
+
+ const average = sum / count
+ const p50 = getPercentile(numbers, 50)
+ const p75 = getPercentile(numbers, 75)
+ const p99 = getPercentile(numbers, 99)
+
+ return { average, p50, p75, p99 }
+}
+
+function getPercentile(numbers: number[], percentile: number): number {
+ if (percentile <= 0 || percentile >= 100) {
+ throw new Error('Percentile must be between 0 and 100.')
+ }
+
+ const index = (percentile / 100) * (numbers.length - 1)
+ if (Number.isInteger(index)) {
+ // If the index is an integer, return the corresponding value
+ return numbers[index]
+ } else {
+ // If the index is not an integer, interpolate between two adjacent values
+ const lowerIndex = Math.floor(index)
+ const upperIndex = Math.ceil(index)
+ const lowerValue = numbers[lowerIndex]
+ const upperValue = numbers[upperIndex]
+ const interpolationFactor = index - lowerIndex
+ return lowerValue + (upperValue - lowerValue) * interpolationFactor
+ }
+}
+
+async function main() {
+ const timings = []
+
+ // fire a query before going to the loop
+ await prisma.notes.findMany({
+ take: 20,
+ })
+
+ // we recommend evaluationg Prisma Accelerate with a large loop
+ const LOOP_LENGTH = 10000
+
+ for (let i = 0; i < LOOP_LENGTH; i++) {
+ const start = Date.now()
+ await prisma.notes.findMany({
+ take: 20,
+ })
+
+ timings.push(Date.now() - start)
+ }
+
+ const statistics = calculateStatistics(timings)
+ console.log('Average:', statistics.average)
+ console.log('P50:', statistics.p50)
+ console.log('P75:', statistics.p75)
+ console.log('P99:', statistics.p99)
+}
+
+main()
+ .then(async () => {
+ await prisma.$disconnect()
+ })
+ .catch((e) => {
+ await prisma.$disconnect()
+ process.exit(1)
+ })
+```
+
+## Evaluating Prisma Accelerate caching performance
+
+Prisma Accelerate’s edge cache is also optimized for a high volume of queries. The cache automatically optimizes for repeated queries. As a result, the cache hit rate will increase as the query frequency does. Adding a query result to the cache is also non-blocking, so a short burst of queries might not utilize the cache or a sustained load.
+
+To evaluate Accelerate’s edge caching, you can modify the above script with the below:
+
+```typescript
+import { PrismaClient } from '@prisma/client'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+
+function calculateStatistics(numbers: number[]): {
+ average: number
+ p50: number
+ p75: number
+ p99: number
+} {
+ if (numbers.length === 0) {
+ throw new Error('The input array is empty.')
+ }
+
+ // Sort the array in ascending order
+ numbers.sort((a, b) => a - b)
+
+ const sum = numbers.reduce((acc, num) => acc + num, 0)
+ const count = numbers.length
+
+ const average = sum / count
+ const p50 = getPercentile(numbers, 50)
+ const p75 = getPercentile(numbers, 75)
+ const p99 = getPercentile(numbers, 99)
+
+ return { average, p50, p75, p99 }
+}
+
+function getPercentile(numbers: number[], percentile: number): number {
+ if (percentile <= 0 || percentile >= 100) {
+ throw new Error('Percentile must be between 0 and 100.')
+ }
+
+ const index = (percentile / 100) * (numbers.length - 1)
+ if (Number.isInteger(index)) {
+ // If the index is an integer, return the corresponding value
+ return numbers[index]
+ } else {
+ // If the index is not an integer, interpolate between two adjacent values
+ const lowerIndex = Math.floor(index)
+ const upperIndex = Math.ceil(index)
+ const lowerValue = numbers[lowerIndex]
+ const upperValue = numbers[upperIndex]
+ const interpolationFactor = index - lowerIndex
+ return lowerValue + (upperValue - lowerValue) * interpolationFactor
+ }
+}
+
+async function main() {
+ const timings = []
+
+ // fire a query before going to the loop
+ await prisma.notes.findMany({
+ take: 20,
+ cacheStrategy: {
+ ttl: 30,
+ },
+ })
+
+ // we recommend evaluating Prisma Accelerate with a large loop
+ const LOOP_LENGTH = 10000
+
+ for (let i = 0; i < LOOP_LENGTH; i++) {
+ const start = Date.now()
+ await prisma.notes.findMany({
+ take: 20,
+ cacheStrategy: {
+ ttl: 30,
+ },
+ })
+
+ timings.push(Date.now() - start)
+ }
+
+ const statistics = calculateStatistics(timings)
+ console.log('Average:', statistics.average)
+ console.log('P50:', statistics.p50)
+ console.log('P75:', statistics.p75)
+ console.log('P99:', statistics.p99)
+}
+
+main()
+ .then(async () => {
+ await prisma.$disconnect()
+ })
+ .catch((e) => {
+ await prisma.$disconnect()
+ process.exit(1)
+ })
+```
diff --git a/docs/300-accelerate/580-local-development.mdx b/docs/300-accelerate/580-local-development.mdx
new file mode 100644
index 0000000000..ece970a8f4
--- /dev/null
+++ b/docs/300-accelerate/580-local-development.mdx
@@ -0,0 +1,65 @@
+---
+title: 'Local development'
+metaTitle: 'Accelerate: Local development'
+metaDescription: 'Learn how to use Prisma Accelerate in a development environment.'
+tocDepth: 3
+toc: true
+---
+
+
+
+Prisma Accelerate is designed to scale database connections efficiently in production environments. Prisma Accelerate also provides a global cache to reduce the load on your database and reduce query response time. To leverage Prisma Accelerate, it is essential to utilize a publicly accessible database.
+
+In development environments, you may want to use a local database to minimize expenses. Furthermore, you may consider extending Prisma Client with the Accelerate client extension once so that you can use a local database in development and a hosted database with Accelerate’s connection pooling and caching enabled. This eliminates the need for conditional logic to switch clients between development and production.
+
+This guide will explain how to use Prisma Accelerate client extension in a development environment with a local database.
+
+
+
+## Using Prisma Accelerate client extension in development and production
+
+
+
+
+Accelerate does not work with a local database. However, in a development environment, you can still use Prisma Client with the Accelerate client extension. This setup will not provide Accelerate's connection pooling and caching features.
+
+The following steps outline how to use Prisma ORM and Prisma Accelerate with a local PostgreSQL database.
+
+1. Update the `DATABASE_URL` environment variable with your local database's connection string:
+
+ ```.env
+ DATABASE_URL="postgres://username:password@127.0.0.1:5432/localdb"
+ ```
+
+2. Generate a Prisma Client:
+
+ ```bash
+ npx prisma generate
+ ```
+
+ > Note: The `--no-engine` flag should only be used in preview and production environments. The command generates Prisma Client artifacts without a [Query Engine](/orm/more/under-the-hood/engines) file, which requires an Accelerate connection string.
+
+3. Set up Prisma Client with the Accelerate client extension:
+
+ ```typescript
+ import { PrismaClient } from '@prisma/client'
+ import { withAccelerate } from '@prisma/extension-accelerate'
+
+ const prisma = new PrismaClient().$extends(withAccelerate())
+ ```
+
+ > The extended instance of Prisma Client will use the local database. Hence, Prisma Accelerate will not be used in your development environment to respond to your Prisma Client queries.
+
+
+
+If an Accelerate connection string is used as the `DATABASE_URL` environment variable, Prisma Client will route your queries through Accelerate.
+
+## Using Prisma Accelerate locally in an edge function
+
+When using an edge function, e.g., [Vercel's edge functions](https://vercel.com/docs/functions/edge-functions), for your development environment, update your Prisma Client import as follows:
+
+```typescript
+import { PrismaClient } from '@prisma/client/edge'
+```
+
+Generally, edge function environments lack native support for existing APIs enabling TCP-based database connections. Prisma Accelerate provides a connection string that allows querying your database over HTTP, a protocol supported in all edge runtimes.
diff --git a/docs/300-accelerate/600-faq.mdx b/docs/300-accelerate/600-faq.mdx
new file mode 100644
index 0000000000..0e525c8ca5
--- /dev/null
+++ b/docs/300-accelerate/600-faq.mdx
@@ -0,0 +1,99 @@
+---
+title: 'FAQ'
+metaTitle: 'Accelerate: FAQ'
+metaDescription: 'Frequently asked questions about Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+Below are frequently asked questions about Accelerate.
+
+## Why do I sometimes see unexpected cache behavior?
+
+Accelerate's cache performs best when it observes a higher load from a project. Many cache operations, such as committing data to cache and refreshing stale data, happen asynchronously. When benchmarking Accelerate, we recommend doing so with loops or a load testing approach. This will mimic higher load scenarios better and reduce outliers from low frequency operations.
+
+Prisma operations are sent to Accelerate over HTTP. As a result, the first request to Accelerate must establish an HTTP handshake and may have additional latency as a result. We're exploring ways to reduce this initial request latency in the future.
+
+## What is the pricing of Accelerate?
+
+You can find more details on our [Accelerate pricing page](https://www.prisma.io/pricing)
+
+## VS Code does not recognize the `$extends` method
+
+If you add the Prisma Client extension for Accelerate to an existing project that is currently open in VS Code, the editor might not immediately recognize the `$extends` method.
+
+This might be an issue with the TypeScript server not yet recognizing the regenerated Prisma Client. To resolve this, you need to restart TypeScript.
+
+1. In VS Code, open the Command Palette. You can do so when you press F1 or select **View** > **Command Palette**.
+2. Enter `typescript` and select and run the **TypeScript: Restart TS server** command.
+
+VS Code should now recognize the `$extends` method.
+
+## What regions are Accelerate's cache nodes available in?
+
+Accelerate runs on Cloudflare's network and cache hits are served from Cloudflare's 300+ locations. You can find the regions where Accelerate's cache nodes are available here: [https://www.cloudflare.com/network/](https://www.cloudflare.com/network/).
+
+## What regions is Accelerate's connection pool available in?
+
+When no cache strategy is specified or in the event of a cache miss, the Prisma Client query is routed through Accelerate's connection pool. Currently, queries can be routed through any chosen region among the 16 available locations.
+
+Currently, the list of available regions are:
+
+- Asia Pacific, Mumbai (`ap-south-1`)
+- Asia Pacific, Seoul (`ap-northeast-2`)
+- Asia Pacific, Singapore (`ap-southeast-1`)
+- Asia Pacific, Sydney (`ap-southeast-2`)
+- Asia Pacific, Tokyo (`ap-northeast-1`)
+- Canada, Central (`ca-central-1`)
+- Europe, Frankfurt (`eu-central-1`)
+- Europe, Ireland (`eu-west-1`)
+- Europe, London (`eu-west-2`)
+- Europe, Paris (`eu-west-3`)
+- Europe, Stockholm (`eu-north-1`)
+- South America, Sao Paulo (`sa-east-1`)
+- US East, N. Virginia (`us-east-1`)
+- US East, Ohio (`us-east-2`)
+- US West, N. California (`us-west-1`)
+- US West, Oregon (`us-west-2`)
+
+You can also view the available regions when you're about to set up Accelerate or by visiting the **Settings** tab for Accelerate under the **Region** section in the Prisma Cloud Platform [dashboard](https://pris.ly/pdp).
+
+## How does Accelerate know what region to fetch the cache from?
+
+Under the hood, Accelerate uses Cloudflare, which uses [Anycast](https://www.cloudflare.com/learning/cdn/glossary/anycast-network/) for network addressing and routing. An incoming request will be routed to the nearest data center or "node" in their network that has the capacity to process the request efficiently. To learn more about how this works, we recommend looking into [Anycast](https://www.cloudflare.com/learning/cdn/glossary/anycast-network/).
+
+## How can I invalidate a cache on Accelerate?
+
+You can invalidate your cache on a project level up to five times a day. This can be done via the Accelerate configuration page.
+
+## What is Accelerate's consistency model?
+
+Accelerate does not have a consistency model. It is not a distributed system where nodes need to reach a consensus (because data is only stored in the cache node(s) closest to the user). However, the data cached in Accelerate's cache nodes doesn't propagate to other nodes, so Accelerate by design doesn't need a consistency model.
+
+Accelerate implements a [read-through caching strategy](https://www.prisma.io/dataguide/managing-databases/introduction-database-caching#read-through) particularly suitable for read-heavy workloads.
+
+The freshness of the data served by the cache depends on the cache strategy defined in your query. Refer to [this section](https://www.notion.so/Accelerate-documentation-469a2162ab71487e9027403249d9b58f?pvs=21) for more information on selecting the right cache strategy for your query.
+
+## How is Accelerate different from other caching tools, such as Redis?
+
+- Accelerate is a _specialized_ cache that allows you to optimize data access in code at the query level with a cache strategy. On the other hand, tools such as Redis and Memcached are _general-purpose_ caches designed to be adaptable and flexible.
+- Accelerate is a managed service that reduces the time, risk, and engineering effort of building and maintaining a cache service.
+- By default, Accelerate is globally distributed, reducing the latency of your queries. Other cache tools would require additional configuration to make them available globally.
+
+## When should I not use Accelerate's caching features?
+
+Accelerate is a global data cache and connection pool that allows you to optimize data access in code at the query level. While caching with Accelerate can greatly boost the performance of your app, it may not always the best choice for your use case.
+
+Accelerate's global cache feature may not be a good fit for your app if:
+
+- Your app is exclusively used within a specific region and both your application server and database are situated in that same region on the same network. For example, database queries will likely be much faster if your application server and database are in the same region and network. However, If your application server is in different regions or networks from your database, Accelerate will speed up your queries because the data will be cached in the closest data center to your application.
+
+- You _only_ need a general-purpose cache. Accelerate is a connection pooler and a _specialized cache_ that only caches your database query responses in code. A general-purpose cache, such as Redis, would allow you to cache data from multiple sources, such as external APIs, which Accelerate currently doesn't support. If general-purpose caching interests you, please share your feedback with us in the [`#accelerate-feedback`](https://prisma.slack.com/archives/C04KTN0V2Q0) channel on our Slack community.
+
+- Your application data _always_ needs to be up-to-date on retrieval, which would be difficult to set a reasonable cache strategy.
+
+Even without using Accelerate's global cache, you can still greatly benefit from Accelerate by using its connection pool, especially in serverless or edge functions, where it is difficult to manage and scale database connections. You can learn more about the serverless challenge [here](/orm/prisma-client/setup-and-configuration/databases-connections#the-serverless-challenge).
+
+## Can I use Accelerate with other ORMs/query builders/drivers?
+
+No. We currently do not have any plans for supporting other ORMs/query builders or drivers. However, if you're interested in support for other libraries, feel free to reach out and let us know in our [Discord](https://pris.ly/discord) community in the `#accelerate-feedback` channel.
diff --git a/docs/300-accelerate/700-feedback.mdx b/docs/300-accelerate/700-feedback.mdx
new file mode 100644
index 0000000000..08755185e4
--- /dev/null
+++ b/docs/300-accelerate/700-feedback.mdx
@@ -0,0 +1,13 @@
+---
+title: 'Feedback'
+metaTitle: 'Accelerate: Feedback'
+metaDescription: 'Learn where to submit feedback about Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+
+
+You can submit any feedback about Accelerate in the [#accelerate-feedback](https://prisma.slack.com/archives/C04KTN0V2Q0) channel in our community [Slack](https://slack.prisma.io/) and in our [Discord server](https://discord.gg/prisma-937751382725886062).
+
+
diff --git a/docs/300-accelerate/index.mdx b/docs/300-accelerate/index.mdx
new file mode 100644
index 0000000000..e1e11ae428
--- /dev/null
+++ b/docs/300-accelerate/index.mdx
@@ -0,0 +1,16 @@
+---
+title: 'Accelerate'
+metaTitle: 'Prisma Accelerate'
+metaDescription: 'Prisma Accelerate is a global database cache with built-in connection pooling that helps improve database performance in Serverless and Edge applications.'
+toc: false
+---
+
+
+
+[Prisma Accelerate](https://www.prisma.io/data-platform/accelerate) is a global database cache and scalable connection pool that helps improve database performance in Serverless and Edge applications.
+
+
+
+## In this section
+
+
diff --git a/static/img/accelerate/accelerate-update-database-connection-string.png b/static/img/accelerate/accelerate-update-database-connection-string.png
new file mode 100644
index 0000000000000000000000000000000000000000..271d4f2bde49b71d9daaa9e4e541af3f705b99fd
GIT binary patch
literal 46693
zcmc$`2UOEpw>NB=!A22L=`ezVNGEg%j7m{yBPd80LT`~C`pk&Z0ue!4C`uJ6q1OOP
zN$5x~fkX%pdI$kR3Gf9R=b3w-d*5~6?|awxW-Z#u&N=(+v;XJp-*4|j#BaKq3>P^r
zo;r1k;o$={{ZpsTVo#kqgFH`1Yhf3#@1^~?@Zy27=c!Ydt{i`z9+(QIo;vl*sfTKJ
zpFk#78qSq)wLNn$Hj<;qZR>a&p0JIlIZE^`7~qI7_Z;^iTTy}GdDti
zy2pMa{*~0d+g1`|bSy3&(sUq?UIoHoMjm4CtNq$TBQtaJ2ttwnqdHH!`R>il?#1dR
zL_p(<#hgSs=I<|K#Xzfpq4B$F-(LxgmL-(G{;(0!K#KnKmt1sp`1cpe^e<6qEZ_GR
z2lzkBI3U%(3;nxHKP2jVKmRV1NxJ^MqkorC!;5|&>mM?v=l}1H|JOXi|2D|Kbga7k
z-`eQk=k~XaHvA;9msmwFl37LQ$@Ah1mv_V(2P1EOpQSL8ggWILKP{HI``t>h*RT*@
zo9ud%Sxn~-nF^AHVXl&u?c1F6;nH<-&|%c|cO^V0_C}fFMF+6mX(5hD?xi=yjGw1n
zJ~noAHBJ4&h9@7)3VDwQ$|Q|IAMfi7;q{$#_pU}?wH_e{eTIcl@h=7*3Jy=YwT3fW^~j7Cj?HUX?&&`Z+8S=z
zC1hCoDvbzf5Jt^?ryP_qPDsi90Ahph&XQ4+NoiBaes#ztO>XZePx<#N5kW;r9_~~1
zD`i@{)Ow#)lTvWw5$@;!XUa{qgS%euQpABPx2~9i8@vnf@}yRlmXIS#h*2TheWh->
zc$G&8VXJs96(F=yLVg&_t+f)e{`(8m`wQ2WS1Ns*HWbZ$Rb{w>hu%o|Y@~kLZ)aC@
zGNDp;RQU0@UD>bIM`JaCJAQ+BTtf^ehmY{8YEUn3cw1>J^OaS1Yt+n<-cmrY-+||A
zortbIdvwU&@9ys7;bi;2b_aZeGAEc`F8c{NMjG1?KoNsi(eyrw?(*MUcx>@np}11?
z@fh#ndYDWP-%2$uxTt$MNfOlDMD1!CnxrE?bEWgB0u5CAV;H#POLS12_f3gAwC!}&
z5S_tEL>7ABdt}>UUh%Q5BFo>4qV_{sbU)S;k9J^3;c0wY7)SXwL{psjEXMfSk$G|t1}VD|@YDpnKfQO%nJgyq6Pz)A@yV`J|e
zuj1`sz3QO-cZsXxtD7ZzPE8D~y%z7kZ;#QG4JRboeTvF^78{ESNb?>Mf>)kpQkD>d
zOW8hp6#!(5pbFCCccBz}G9-Tr~(J~{qL$;SKkLp^Wl=Xg5=4nUI>#ua=R25zN
z=f*DLr(~kkD4g;tZug~YCsZO!`nGLR}BvX(cHcw;)0?|qDPB*AtsVMskbG&JO+(j
zmFPW5kOv6e407+91_~}YTI-%$egnr#h|Ao_{w)5iy6%5E!hN$aC(0!e1WYQf6Bl5{k-mnhzp|X9qPyrM?3~)59RUpv**DkI5(uchmGVBfO77UH3iHF=N5VxKueTMMZd;VrCT2ODF^yMnT>Fn*|<&_DeNvGd)Ek~+P_tyi?C==Y=wYyCBJBH
zD#~d@Q>2WRQM5Yk9C#!dBT!iEUBYAbyE2r`8G)zbUj{TZq4FEtx1dfZdi&FJ2NA7_jo0P9HSsqNkGAP4Hj
zbU_fvjZWK_8Yz%Nc7QE`?nQIxg=-mzx}{HZec@}ePi4vTPglxQ{wS_ASMlRyp5m*O
z>{DWPVh1Z;+5qKO^(j{ZRne1>QTTZ=@AF?H?%q+%--I@Z*#TzzH))IC8?J#qm?8#O
zQx%d=aa$o-vO|gGAxDwn-cndcsvH#g+^`_%`KLbR0PEx#UsojQu@#2q#|-2fVT?{P
z5vKi+xJT(kma`e)@;O5^`iTcB4_q(*E~px~mmn{bn@NZb_#TBhAQSK7&7-X+{7kid
zO`*P|%BP>{#}#(%q5QqoefFmb-p_ji1>>^j07-HIg}XjIzb*yv<9n1kF=c(qQz~*;
zWN)D%$B|P(k)gL`Tg2RiHIhtrq|={LYK8##cV?5x1;ufBDS%@5mY%$$&6L-c6PHix
zH-{P~qPLrwYL9Z99a$r
zRm4ex3l`m?NGdzuUSe#%NzCkSYey!iXt6|A%FIM7n7>`^mB&NtX7TCH>|l!<2?>a5
ztUm)K8D<4WK?wN5h*ZFQ+Gs&E4^Xl3PnU<$a&aAVX{^yP0me{Lu|3kNpa=#7L<(l5
zZ@X`jTCybdu3GYH#HVf<9<<$<9))i^Z2>F!u)8WZbaLsSMBT?bUW|cY6Cc#)3qPI)
z!~>L4^6I94X^ujHLfoHobWCL9P+xb#@@%ZD0OP*&qbA?saPfJb7=`(yjg1WItl->g
zB;xQ)Bfo26NIGxVP`*K;16P0>l6;{z=|+R-XiY3>UdCdPj0l_)F4A9$8mDuW#3GwT
zgSIn{b~CsQ5tu;;6Nh50@_hXW8+gHYWXEv-(c+R?16&e2ybZSiCD>^n&4~v*>9$F?
zlSh9Wjhu1*9#`WVxHyT@$rA&CY0p%c*|k&UOXutSY~UYVO?nFoHjGT>;$UBNl~$h|
zrXCrY_C8w)H1rf;@3LR%~+k%A)88tmqO?k;1+J
zq~v_dq
z&g_gco-bUBhEk}zWMP4qE$7K~Qi}4BVdDmx=k*75?tHz^RMalpj@#;?
z{I*6&_0$balmk={GMIx#X_4azPLakYlPuo4PaUt1FlStH_xO!4E`8r1zJ}U|-IgTv
z3BcoJe^5(QT-j-SDtm^RGbcSiV)9eMYYVW_n01tB$|D&)+q+L{u!j=kEw34z<49r}
z+fjw(y^7aRNC#xCK$~miJY9VoQu%8gIc1|md2ueSo5kcLpkD1VevPFBdlvZXlU
z{u0DJjTTj*pKM#_{oHakCC$+SU-To&Aap{i&vh*!A70{B@^O(4+^t#FkRY*Xz+DYE
z0?IMW3ig<)Kub}HCa-&!r`)<`U3+ZUB!W{tgmmLa=(Y9H?oR;(Kf^OZ8_;sF7Q1X$
z^Q#o+AKQWqwrdj76&X!O10~0(g9ChwLlXEr3C<-2cWa-ip1`MLUHSvXfBuhP<>W0J
zbpVzIlg#XL;lwJbh!cd~-`1ln-M9p_laOZIzRXL2E$H6VimWH0HyWdzBAv75
zAJ4Gd1DESloYV*o7<+6rrBfIB^QG&B>l88#V>KhH$8M~Yhxj5IXftp?F5f*Hm}6PU
z8eGg?pVDgbvzrUDDnn(s~pR5>0U^eHM)DX`#vG4vx4
z_@yPd{3ng&NeI2G>v>*}1?CR{eOVLKpjE$K;WJwPQwb*M_FdM{Ri8EBWWU6|RWF+6;sUT9TBuuQ;Fgstmb33|8=00>;n!Wni2GPuKT>6)kQ>kW
zFrm|5lx-c;C(>9M&gpXdu*wmPh)d~Kuhk)S_gbtp{q_+Rvc=YLfaD;i`Cv@J<#mVNp_g!WWyC`e&xLDG%Fx)F`(Oa;$Rxuu654LvOu`&>^(
zAsKT1+K%JXr1GWj4UKq-o5)!y7
zin$#GQ_bfCB9rNOmoo;cL&oxlepxGElp9fb8eyK#jrRhVxqYHA
zr;dmiVs|dA9N5R+%L|aTIH#{TZYeY9HUGK1YkA##Ft5+$6Jz$O>~a}s(wFCFx9uIV
zS{sY}R6Qo8l>t$g%AnC_h>e(3uPFhY^eeDv&}2Z<{pNTfg942#rnO)-Gy72>B`Rc8
zDR|p+BmZ48`#$d^zsB^2ZDC6tHDslRL`w0P#0zS>co*#=i_qrT$
O}xB-0qtfbaFEF(iDM=23DMF
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
I9h+DG1zu;5ssI20
literal 0
HcmV?d00001
diff --git a/static/img/accelerate/accelerate.png b/static/img/accelerate/accelerate.png
new file mode 100644
index 0000000000000000000000000000000000000000..408d30212edd7e787cce46ba88e8fab2f36af9db
GIT binary patch
literal 253464
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