feat(platform): IA rework

.github/styles/config/vocabularies/Docs/accept.txt

@@ -53,7 +53,7 @@ proxied
 LLM
 embedder
 chatbot
-[Ll]angchain
+[Ll]angChain
 
 [Kk]eboola
 [Aa]irbyte
@@ -68,7 +68,7 @@ exploitability
 [Ww]hitepaper
 [Cc]ron
 scalably
-metamorph
+[Mm]etamorph
 hostname
 IPs
 unscoped

nginx.conf

@@ -26,6 +26,56 @@ server {
     return 200 '{"status":"UP"}';
   }
 
+  # ===================================================================
+  # Platform IA Reorganization - Phase 3 Redirects
+  # ===================================================================
+
+  # Using Actors (from actors/running)
+  rewrite ^/platform/actors/running/?$ /platform/using-actors permanent;
+  rewrite ^/platform/actors/running/(.+)$ /platform/using-actors/$1 permanent;
+
+  # Core Concepts - Storage
+  rewrite ^/platform/storage/?$ /platform/core-concepts/storage permanent;
+  rewrite ^/platform/storage/(.+)$ /platform/core-concepts/storage/$1 permanent;
+
+  # Core Concepts - Proxy
+  rewrite ^/platform/proxy/?$ /platform/core-concepts/proxy permanent;
+  rewrite ^/platform/proxy/(.+)$ /platform/core-concepts/proxy/$1 permanent;
+
+  # Building Actors (from actors/development)
+  rewrite ^/platform/actors/development/?$ /platform/building-actors permanent;
+  rewrite ^/platform/actors/development/(.+)$ /platform/building-actors/$1 permanent;
+
+  # Publishing & Monetization (from actors/publishing)
+  rewrite ^/platform/actors/publishing/?$ /platform/publishing-and-monetization permanent;
+  rewrite ^/platform/actors/publishing/(.+)$ /platform/publishing-and-monetization/$1 permanent;
+
+  # ===================================================================
+  # Platform IA Reorganization - Phase 4 Redirects
+  # ===================================================================
+
+  # Getting Started (from building-actors/quick-start)
+  rewrite ^/platform/building-actors/quick-start/?$ /platform/getting-started permanent;
+  rewrite ^/platform/building-actors/quick-start/locally/?$ /platform/getting-started/locally permanent;
+  rewrite ^/platform/building-actors/quick-start/web-ide/?$ /platform/getting-started/web-ide permanent;
+  rewrite ^/platform/building-actors/quick-start/build-with-ai/?$ /platform/getting-started/build-with-ai permanent;
+
+  # Integrations (no path change, but ensure consistency)
+  # Note: Integrations already at /platform/integrations - no redirect needed
+
+  # Collaboration
+  rewrite ^/platform/collaboration/?$ /platform/collaboration permanent;
+  rewrite ^/platform/collaboration/(.+)$ /platform/collaboration/$1 permanent;
+
+  # Monitoring & Operations (from monitoring)
+  rewrite ^/platform/monitoring/?$ /platform/monitoring-and-operations/monitoring permanent;
+  rewrite ^/platform/monitoring/(.+)$ /platform/monitoring-and-operations/monitoring/$1 permanent;
+
+  # Reference (orphaned files)
+  rewrite ^/platform/limits$ /platform/reference/limits permanent;
+  rewrite ^/platform/security$ /platform/reference/security permanent;
+  rewrite ^/platform/schedules$ /platform/reference/schedules permanent;
+
   # generated via `node tools/convert.mjs` inside the docs repository
   rewrite ^/about$ /platform/about permanent;
   rewrite ^/access-rights$ /platform/access-rights permanent;

sources/academy/ai/ai-agents.mdx

@@ -52,7 +52,7 @@ _Example input:_
 _Example output:_
 
 - Text response with insights
-- Data stored in Apify [Dataset](/platform/storage/dataset)
+- Data stored in Apify [Dataset](/platform/core-concepts/storage/dataset)
 
 :::note Agent memory
 

sources/academy/glossary/tools/apify_cli.md

@@ -15,7 +15,7 @@ The [Apify CLI](/cli) helps you create, develop, build and run Apify Actors, and
 
 ## Installing {#installing}
 
-To install the Apfiy CLI, you'll first need npm, which comes preinstalled with Node.js. If you haven't yet installed Node, learn how to do that [here](../../webscraping/scraping_basics_javascript/data_extraction/computer_preparation.md). Additionally, make sure you've got an Apify account, as you will need to log in to the CLI to gain access to its full potential.
+To install the Apfiy CLI, you'll first need npm, which comes preinstalled with Node.js. If you haven't yet installed Node, [learn how to prepare your computer](../../webscraping/scraping_basics_javascript/data_extraction/computer_preparation.md). Additionally, make sure you've got an Apify account, as you will need to log in to the CLI to gain access to its full potential.
 
 Open up a terminal instance and run the following command:
 

sources/academy/platform/actorization_playbook.mdx

@@ -58,14 +58,14 @@ You can Actorize various projects ranging from open-source libraries, throughout
 
 Use these criteria to decide if your project is a good candidate for Actorization:
 
-1. _Is it self-contained?_ Does the project work non-interactively, with a well-defined, preferably structured input and output format? Positive examples include various data processing utilities, web scrapers and other automation scripts. Negative examples are GUI applications or applications that run indefinitely. If you want to run HTTP APIs on Apify, you can do so using [Actor Standby](/platform/actors/development/programming-interface/standby).
-2. _Can the state be stored in Apify storages?_ If the application has state that can be stored in a small number of files it can utilize [key-value store](/platform/storage/key-value-store), or if it processes records that can be stored in Apify’s [request queue](/platform/storage/request-queue). If the output consists of one or many similar JSON objects, it can utilize [dataset](/platform/storage/dataset).
+1. _Is it self-contained?_ Does the project work non-interactively, with a well-defined, preferably structured input and output format? Positive examples include various data processing utilities, web scrapers and other automation scripts. Negative examples are GUI applications or applications that run indefinitely. If you want to run HTTP APIs on Apify, you can do so using [Actor Standby](/platform/using-actors/development/programming-interface/standby).
+2. _Can the state be stored in Apify storages?_ If the application has state that can be stored in a small number of files it can utilize [key-value store](/platform/core-concepts/storage/key-value-store), or if it processes records that can be stored in Apify’s [request queue](/platform/core-concepts/storage/request-queue). If the output consists of one or many similar JSON objects, it can utilize [dataset](/platform/core-concepts/storage/dataset).
 3. _Can it be containerized?_ The project needs to be able to run in a Docker container. Apify currently does not support GPU workloads. External services (e.g., databases) need to be managed by developer.
 4. _Can it use Apify tooling?_ Javascript/Typescript applications and Python applications can be Actorized with the help of the [Apify SDK](/sdk), which makes easy for your code to interacts with the Apify platform. Applications that can be run using just the CLI can also be Actorized using the Apify CLI by writing a simple shell script that retrieves user input using [Apify CLI](/cli/), then runs your application and sends the results back to Apify (also using the CLI). If your application is implemented differently, you can still call the [Apify API](/api/v2) directly - it’s just HTTP and pretty much every language has support for that but the implementation is less straightforward.
 
 ## Actorization guide
 
-This guide outlines the steps to convert your application into an Apify [Actor](/platform/actors). Follow the documentation links for detailed information - this guide provides an overview rather than exhaustive instructions.
+This guide outlines the steps to convert your application into an Apify [Actor](/platform/using-actors). Follow the documentation links for detailed information - this guide provides an overview rather than exhaustive instructions.
 
 ### 1. Add Actor metadata - the `.actor` folder
 
@@ -83,14 +83,14 @@ In case you're starting a new project, we strongly advise to start with a [templ
 
     :::note Quick Start for beginners
 
-    For a step-by-step introduction to creating your first Actor (including tech stack choices and development paths), see [Quick Start](/platform/actors/development/quick-start).
+    For a step-by-step introduction to creating your first Actor (including tech stack choices and development paths), see [Getting started](/platform/getting-started).
 
     :::
 
 
-The newly created `.actor` folder contains an `actor.json` file - a manifest of the Actor. See [documentation](/platform/actors/development/actor-definition/actor-json) for more details
+The newly created `.actor` folder contains an `actor.json` file - a manifest of the Actor. See [documentation](/platform/using-actors/development/actor-definition/actor-json) for more details
 
-You must also make sure your Actor has a Dockerfile and that it installs everything needed to successfully run your application. Check out [Dockerfile documentation](/platform/actors/development/actor-definition/dockerfile) by Apify. If you don't want to use these, you are free to use any image as the base of your Actor.
+You must also make sure your Actor has a Dockerfile and that it installs everything needed to successfully run your application. Check out [Dockerfile documentation](/platform/using-actors/development/actor-definition/dockerfile) by Apify. If you don't want to use these, you are free to use any image as the base of your Actor.
 
 When launching the Actor, the Apify platform will simply run your Docker image. This means that a) you need to configure the `ENTRYPOINT` and `CMD` directives so that it launches your application and b) you can test your image locally using Docker.
 
@@ -100,7 +100,7 @@ These steps are the bare minimum you need to run your code on Apify. The rest of
 
 Most Actors accept an input and produce an output. As part of Actorization, you need to define the input and output structure of your application.
 
-For detailed information, read the docs for [input schema](/platform/actors/development/actor-definition/input-schema), [dataset schema](/platform/actors/development/actor-definition/dataset-schema), and general [storage](/platform/storage).
+For detailed information, read the docs for [input schema](/platform/using-actors/development/actor-definition/input-schema), [dataset schema](/platform/using-actors/development/actor-definition/dataset-schema), and general [storage](/platform/core-concepts/storage).
 
 
 #### Design guidelines
@@ -113,11 +113,11 @@ For detailed information, read the docs for [input schema](/platform/actors/deve
 
 ### 3. Handle state persistence (optional)
 
-If your application performs a number of well-defined subtasks, the [request queue](/platform/storage/request-queue) lets you pause and resume execution on job restart. This is important for long-running jobs that might be migrated between servers at some point. In addition, this allows the Apify platform to display the progress to your users in the UI.
+If your application performs a number of well-defined subtasks, the [request queue](/platform/core-concepts/storage/request-queue) lets you pause and resume execution on job restart. This is important for long-running jobs that might be migrated between servers at some point. In addition, this allows the Apify platform to display the progress to your users in the UI.
 
 A lightweight alternative to the request queue is simply storing the state of your application as a JSON object in the key-value store and checking for that when your Actor is starting.
 
-Fully-fledged Actors will often combine these two approaches for maximum reliability. More on this topic you find in the [state persistence](/platform/actors/development/builds-and-runs/state-persistence) article.
+Fully-fledged Actors will often combine these two approaches for maximum reliability. More on this topic you find in the [state persistence](/platform/using-actors/development/builds-and-runs/state-persistence) article.
 
 ### 4. Write Actorization code
 
@@ -127,12 +127,12 @@ Unless you’re writing an application targeted directly on the Apify platform,
 
 Apify provides SDKs for [Javascript](/sdk/js/) and [Python](/sdk/python/) plus a [Apify CLI](/cli/) allowing an easy interaction with Apify platform from command line.
 
-Check out [programming interface](/platform/actors/development/programming-interface/) documentation article for details on interacting with the Apify platform in your Actor's code.
+Check out [programming interface](/platform/using-actors/development/programming-interface/) documentation article for details on interacting with the Apify platform in your Actor's code.
 
 ### 5. Deploy the Actor
 
-Deployment to Apify platform can be done easily via `apify push` command of [Apify CLI](/cli/) and for details see [deployment](/platform/actors/development/deployment) documentation.
+Deployment to Apify platform can be done easily via `apify push` command of [Apify CLI](/cli/) and for details see [deployment](/platform/using-actors/development/deployment) documentation.
 
 ### 6. Publish and monetize
 
-For details on publishing the Actor in [Apify Store](https://apify.com/store) see the [Publishing and monetization](/platform/actors/publishing). You can also follow our guide on [How to create an Actor README](/academy/actor-marketing-playbook/actor-basics/how-to-create-an-actor-readme) and [Actor marketing playbook](/academy/actor-marketing-playbook).
+For details on publishing the Actor in [Apify Store](https://apify.com/store) see the [Publishing and monetization](/platform/publishing-and-monetization/publish). You can also follow our guide on [How to create an Actor README](/academy/actor-marketing-playbook/actor-basics/how-to-create-an-actor-readme) and [Actor marketing playbook](/academy/actor-marketing-playbook).

sources/academy/platform/deploying_your_code/deploying.md

@@ -39,7 +39,7 @@ The final step is to click on **API** in the top right corner of our Actor's pag
 
 And scroll through all of the links until we find the **Build Actor** API endpoint. Now we'll copy this endpoint's URL, head back over to our GitHub repository and navigate to **Settings > Webhooks > Add webhook**. The final thing to do is to paste the URL and save the webhook.
 
-![Adding a webhook to your GitHub repository](../../../platform/actors/development/deployment/images/ci-github-integration.png)
+![Adding a webhook to your GitHub repository](../../../platform/5-building-actors/deployment/images/ci-github-integration.png)
 
 That's it! The Actor should now pull its source code from the repository and automatically build.
 
@@ -63,4 +63,4 @@ The next step is to test your Actor and experiment with the vast amount of featu
 
 ## Wrap up {#next}
 
-That's it! In this short section, you've learned how to take your code written in any programming language and turn it into a usable Actor that can run on the Apify platform! The next step is to start looking into the [paid Actors](/platform/actors/publishing) program, which allows you to monetize your work.
+That's it! In this short section, you've learned how to take your code written in any programming language and turn it into a usable Actor that can run on the Apify platform! The next step is to start looking into the [paid Actors](/platform/publishing-and-monetization/publish) program, which allows you to monetize your work.

sources/academy/platform/deploying_your_code/input_schema.md

@@ -9,7 +9,7 @@ slug: /deploying-your-code/input-schema
 
 ---
 
-Though writing an [input schema](/platform/actors/development/actor-definition/input-schema) for an Actor is not a required step, it is most definitely an ideal one. The Apify platform will read the **INPUT_SCHEMA.json** file within the root of your project and generate a user interface for entering input into your Actor, which makes it significantly easier for non-developers (and even developers) to configure and understand the inputs your Actor can receive. Because of this, we'll be writing an input schema for our example Actor.
+Though writing an [input schema](/platform/using-actors/development/actor-definition/input-schema) for an Actor is not a required step, it is most definitely an ideal one. The Apify platform will read the **INPUT_SCHEMA.json** file within the root of your project and generate a user interface for entering input into your Actor, which makes it significantly easier for non-developers (and even developers) to configure and understand the inputs your Actor can receive. Because of this, we'll be writing an input schema for our example Actor.
 
 > Without an input schema, the users of our Actor will have to provide the input in JSON format, which can be problematic for those who are not familiar with JSON.
 
@@ -51,7 +51,7 @@ Each property's key corresponds to the name we're expecting within our code, whi
 
 ## Property types & editor types {#property-types}
 
-Within our new **numbers** property, there are two more fields we must specify. Firstly, we must let the platform know that we're expecting an array of numbers with the **type** field. Then, we should also instruct Apify on which UI component to render for this input property. In our case, we have an array of numbers, which means we should use the **json** editor type that we discovered in the ["array" section](/platform/actors/development/actor-definition/input-schema/specification/v1#array) of the input schema documentation. We could also use **stringList**, but then we'd have to parse out the numbers from the strings.
+Within our new **numbers** property, there are two more fields we must specify. Firstly, we must let the platform know that we're expecting an array of numbers with the **type** field. Then, we should also instruct Apify on which UI component to render for this input property. In our case, we have an array of numbers, which means we should use the **json** editor type that we discovered in the ["array" section](/platform/using-actors/development/actor-definition/input-schema/specification/v1#array) of the input schema documentation. We could also use **stringList**, but then we'd have to parse out the numbers from the strings.
 
 ```json
 {
@@ -102,8 +102,8 @@ Here is what the input schema we wrote will render on the platform:
 
 Later on, we'll be building more complex input schemas, as well as discussing how to write quality input schemas that allow the user to understand the Actor and not become overwhelmed.
 
-It's not expected to memorize all of the fields that properties can take or the different editor types available, which is why it's always good to reference the [input schema documentation](/platform/actors/development/actor-definition/input-schema) when writing a schema.
+It's not expected to memorize all of the fields that properties can take or the different editor types available, which is why it's always good to reference the [input schema documentation](/platform/using-actors/development/actor-definition/input-schema) when writing a schema.
 
 ## Next up {#next}
 
-In the [next lesson](/platform/actors/development/actor-definition/dataset-schema), we'll learn how to generate an appealing Overview table to display our Actor's results in real time, so users can get immediate feedback about the data being extracted.
+In the [next lesson](/platform/using-actors/development/actor-definition/dataset-schema), we'll learn how to generate an appealing Overview table to display our Actor's results in real time, so users can get immediate feedback about the data being extracted.