Rename app inputs to parameters (#627)

* app doc updates

Signed-off-by: Niels Bantilan <[email protected]>

* update app input -> parameter

Signed-off-by: Niels Bantilan <[email protected]>

* rename files

Signed-off-by: Niels Bantilan <[email protected]>

* updates

Signed-off-by: Niels Bantilan <[email protected]>

* fixed

Signed-off-by: Ketan Umare <[email protected]>

* Updated unionai-examples commit

Signed-off-by: Ketan Umare <[email protected]>

---------

Signed-off-by: Niels Bantilan <[email protected]>
Signed-off-by: Ketan Umare <[email protected]>
Co-authored-by: Ketan Umare <[email protected]>
Co-authored-by: Ketan Umare <[email protected]>

Author: cosmicBboy

content/user-guide/build-apps/app-usage-patterns.md

@@ -276,16 +276,16 @@ Key points:
 - Access the app endpoint via `env1.endpoint`
 - Use HTTP clients (like `httpx`) to make requests between apps
 
-### Using AppEndpoint input
+### Using AppEndpoint parameter
 
-You can pass app endpoints as inputs for more flexibility:
+You can pass app endpoints as parameters for more flexibility:
 
 ```python
 env2 = FastAPIAppEnvironment(
     name="frontend-api",
     app=app2,
-    inputs=[
-        flyte.app.Input(
+    parameters=[
+        flyte.app.Parameter(
             name="backend_url",
             value=flyte.app.AppEndpoint(app_name="backend-api"),
             env_var="BACKEND_URL",
@@ -477,7 +477,7 @@ To access a browser-based app:
 2. **Handle errors**: Implement proper error handling for HTTP requests.
 3. **Use async clients**: Use async HTTP clients (`httpx.AsyncClient`) in async contexts.
 4. **Initialize Flyte**: For apps calling tasks, initialize Flyte in the app's startup.
-5. **Endpoint access**: Use `app_env.endpoint` or `AppEndpoint` input for accessing app URLs.
+5. **Endpoint access**: Use `app_env.endpoint` or `AppEndpoint` parameter for accessing app URLs.
 6. **Authentication**: Consider authentication when apps call each other (set `requires_auth=True` if needed).
 7. **Webhook security**: Secure webhooks with auth, validation, and HTTPS.
 8. **WebSocket robustness**: Implement connection management, heartbeats, and rate limiting.

content/user-guide/build-apps/fastapi-app.md

@@ -82,8 +82,8 @@ env = FastAPIAppEnvironment(
         "pydantic",
         "joblib",
     ),
-    inputs=[
-        flyte.app.Input(
+    parameters=[
+        flyte.app.Parameter(
             name="model_file",
             value=flyte.io.File("s3://bucket/models/model.joblib"),
             mount="/app/models",

content/user-guide/configure-apps/_index.md

@@ -50,7 +50,7 @@ While `AppEnvironment` inherits from `Environment` (the same base class as `Task
 | `domain` | ✅ | ❌ | Custom domain/subdomain |
 | `links` | ✅ | ❌ | Links to include in the App UI page |
 | `include` | ✅ | ❌ | Files to include in app |
-| `inputs` | ✅ | ❌ | Inputs to pass to app |
+| `parameters` | ✅ | ❌ | Parameters to pass to app |
 | `cluster_pool` | ✅ | ❌ | Cluster pool for deployment |
 
 Parameters like `image`, `resources`, `secrets`, `env_vars`, and `depends_on` are shared between both environment types. See the [task configuration](../task-configuration/) docs for details on these shared parameters.
@@ -63,6 +63,6 @@ Learn more about configuring apps:
 - [**Environment settings**](./app-environment-settings): Images, resources, secrets, and app-specific settings like `type`, `port`, `args`, `requires_auth`
 - [**App startup**](./app-environment-settings#app-startup): Understanding the difference between `args` and `command`
 - [**Including additional files**](./including-additional-files): How to include additional files needed by your app
-- [**App inputs**](./passing-inputs): Pass inputs to your app at deployment time
+- [**App parameters**](./passing-parameters): Pass parameters to your app at deployment time
 - [**Autoscaling apps**](./app-environment-settings#autoscaling-apps): Configure scaling up and down based on traffic with idle TTL
 - [**App depending on other environments**](./apps-depending-on-environments): Use `depends_on` to deploy dependent apps together

content/user-guide/configure-apps/app-environment-settings.md

@@ -110,7 +110,7 @@ This is particularly useful for passing API keys or other sensitive values to co
 > [!TIP]
 > For most `AppEnvironment`s, use `args` instead of `command` to specify the app startup command
 > in the container. This is because `args` will use the `fserve` command to run the app, which
-> unlocks features like local code bundling and file/directory mounting via input injection.
+> unlocks features like local code bundling and file/directory mounting via parameter injection.
 
 ### `command`
 
@@ -201,24 +201,24 @@ app_env = flyte.app.AppEnvironment(
 > [!NOTE]
 > Learn more about including additional files in your app deployment [here](./including-additional-files).
 
-### `inputs`
+### `parameters`
 
-The `inputs` parameter passes inputs to your app at deployment time. Inputs can be primitive values, files, directories, or delayed values like `RunOutput` or `AppEndpoint`.
+The `parameters` parameter passes parameters to your app at deployment time. Parameters can be primitive values, files, directories, or delayed values like `RunOutput` or `AppEndpoint`.
 
 ```python
 app_env = flyte.app.AppEnvironment(
     name="my-app",
-    inputs=[
-        flyte.app.Input(name="config", value="foo", env_var="BAR"),
-        flyte.app.Input(name="model", value=flyte.io.File(path="s3://bucket/model.pkl"), mount="/mnt/model"),
-        flyte.app.Input(name="data", value=flyte.io.File(path="s3://bucket/data.pkl"), mount="/mnt/data"),
+    parameters=[
+        flyte.app.Parameter(name="config", value="foo", env_var="BAR"),
+        flyte.app.Parameter(name="model", value=flyte.io.File(path="s3://bucket/model.pkl"), mount="/mnt/model"),
+        flyte.app.Parameter(name="data", value=flyte.io.File(path="s3://bucket/data.pkl"), mount="/mnt/data"),
     ],
     # ...
 )
 ```
 
 > [!NOTE]
-> Learn more about passing inputs to your app at deployment time [here](./passing-inputs).
+> Learn more about passing parameters to your app at deployment time [here](./passing-parameters).
 
 ### `scaling`
 
@@ -278,7 +278,7 @@ When you don't specify a `command`, Flyte generates a default command that uses
 - Setting up the code bundle
 - Configuring the version
 - Setting up project/domain context
-- Injecting inputs if provided
+- Injecting parameters if provided
 
 The default command looks like:
 
@@ -335,7 +335,7 @@ The `FastAPIAppEnvironment` automatically:
 ### Startup best practices
 
 1. **Use specialized app environments** when available (for example, `FastAPIAppEnvironment`) – they handle command setup automatically.
-2. **Use `args`** when you need code bundling and input injection.
+2. **Use `args`** when you need code bundling and parameter injection.
 3. **Use `command`** for simple, standalone apps that don't need code bundling.
 4. **Always set `port`** to match what your app actually listens on.
 5. **Use `include`** with `args` to bundle your app code files.

content/user-guide/configure-apps/apps-depending-on-environments.md

@@ -78,8 +78,8 @@ backend_env = flyte.app.AppEnvironment(name="backend-api", ...)
 frontend_env = flyte.app.AppEnvironment(
     name="frontend-app",
     depends_on=[backend_env],
-    inputs=[
-        flyte.app.Input(
+    parameters=[
+        flyte.app.Parameter(
             name="backend_url",
             value=flyte.app.AppEndpoint(app_name="backend-api"),
         ),
@@ -88,7 +88,7 @@ frontend_env = flyte.app.AppEnvironment(
 )
 ```
 
-The `backend_url` input will be automatically set to the backend app's endpoint URL.
+The `backend_url` parameter will be automatically set to the backend app's endpoint URL.
 You can get this value in your app code using `flyte.app.get_input("backend_url")`.
 
 ## Deployment behavior

content/user-guide/configure-apps/passing-inputs.md

@@ -0,0 +1,125 @@
+---
+title: Passing parameters into app environments
+weight: 4
+variants: +flyte +serverless +byoc +selfmanaged
+---
+
+# Passing parameters into app environments
+
+`[[AppEnvironment]]`s support various parameter types that can be passed at deployment time. This includes primitive values, files, directories, and delayed values like `RunOutput` and `AppEndpoint`.
+
+## Parameter types overview
+
+There are several parameter types:
+
+- **Primitive values**: Strings, numbers, booleans
+- **Files**: `flyte.io.File` objects
+- **Directories**: `flyte.io.Dir` objects
+- **Delayed values**: `RunOutput` (from task runs) or `AppEndpoint` (inject endpoint urls of other apps)
+
+## Basic parameter types
+
+{{< code file="/external/unionai-examples/v2/user-guide/build-apps/passing-parameters-examples.py" fragment=basic-parameter-types lang=python >}}
+
+## Delayed values
+
+Delayed values are parameters whose actual values are materialized at deployment time.
+
+### RunOutput
+
+Use `RunOutput` to pass outputs from task runs as app parameters:
+
+{{< code file="/external/unionai-examples/v2/user-guide/build-apps/passing-parameters-examples.py" fragment=runoutput-example lang=python >}}
+
+The `type` argument is required and must be one of `string`, `file`, or `directory`.
+When the app is deployed, it will make the remote calls needed to figure out the
+actual value of the parameter.
+
+### AppEndpoint
+
+Use `AppEndpoint` to pass endpoints from other apps:
+
+{{< code file="/external/unionai-examples/v2/user-guide/build-apps/passing-parameters-examples.py" fragment=appendpoint-example lang=python >}}
+
+The endpoint URL will be injected as the parameter value when the app starts.
+
+This is particularly useful when you want to chain apps together (for example, a frontend app calling a backend app), without hardcoding URLs.
+
+## Overriding parameters at serve time
+
+You can override parameter values when serving apps (this is not supported for deployment):
+
+```python
+# Override parameters when serving
+app = flyte.with_servecontext(
+    input_values={"my-app": {"model_path": "s3://bucket/new-model.pkl"}}
+).serve(app_env)
+```
+
+> [!NOTE]
+> Parameter overrides are only available when using `flyte.serve()` or `flyte.with_servecontext().serve()`. 
+> The `flyte.deploy()` function does not support parameter overrides - parameters must be specified in the `AppEnvironment` definition.
+
+This is useful for:
+- Testing different configurations during development
+- Using different models or data sources for testing
+- A/B testing different app configurations
+
+## Example: FastAPI app with configurable model
+
+Here's a complete example showing how to use parameters in a FastAPI app:
+
+{{< code file="/external/unionai-examples/v2/user-guide/configure-apps/app-inputs-fastapi-example.py" lang=python >}}
+
+## Example: Using RunOutput for model serving
+
+{{< code file="/external/unionai-examples/v2/user-guide/build-apps/passing-parameters-examples.py" fragment=runoutput-serving-example lang=python >}}
+
+## Accessing parameters in your app
+
+How you access parameters depends on how they're configured:
+
+1. **Environment variables**: If `env_var` is specified, the parameter is available as an environment variable
+2. **Mounted paths**: File and directory parameters are mounted at the specified path
+3. **Flyte SDK**: Use the Flyte SDK to access parameter values programmatically
+
+```python
+import os
+
+# Parameter with env_var specified
+env = flyte.app.AppEnvironment(
+    name="my-app",
+    parameters=[
+        flyte.app.Parameter(
+            name="model_file",
+            value=flyte.io.File("s3://bucket/model.pkl"),
+            mount="/app/models/model.pkl",
+            env_var="MODEL_PATH",
+        ),
+    ],
+    # ...
+)
+
+# Access in the app via the environment variable
+API_KEY = os.getenv("API_KEY")
+
+# Access in the app via the mounted path
+with open("/app/models/model.pkl", "rb") as f:
+    model = pickle.load(f)
+
+# Access in the app via the Flyte SDK (for string parameters)
+parameter_value = flyte.app.get_parameter("model_file")  # Returns string value
+```
+
+## Best practices
+
+1. **Use delayed parameters**: Leverage `RunOutput` and `AppEndpoint` to create app dependencies between tasks and apps, or app-to-app chains.
+2. **Override for testing**: Use the `input_values` parameter when serving to test different configurations without changing code.
+3. **Mount paths clearly**: Use descriptive mount paths for file/directory parameters so your app code is easy to understand.
+4. **Use environment variables**: For simple constants that you can hard-code, use `env_var` to inject values as environment variables.
+5. **Production deployments**: For production, define parameters in the `AppEnvironment` rather than overriding them at deploy time.
+
+## Limitations
+
+- Large files/directories can slow down app startup.
+- Parameter overrides are only available when using `flyte.with_servecontext(...).serve(...)`.

content/user-guide/configure-apps/passing-parameters.md

@@ -15,7 +15,7 @@ Flyte provides two main ways to deploy apps: **serve** (for development) and **d
 
 Serving is designed for development and iteration:
 
-- **Dynamic input modification**: You can override app inputs when serving
+- **Dynamic parameter modification**: You can override app parameters when serving
 - **Quick iteration**: Faster feedback loop for development
 - **Interactive**: Better suited for testing and experimentation