jyapayne/langflow
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Docs: update api configuration (#4354)

Browse source
This commit is contained in:
Mendon Kissling 2024-11-02 09:18:52 -04:00 • committed by GitHub
commit dc4e0e5ce1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 109 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
docs/docs/Configuration/596474918.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 2.9 KiB

236
docs/docs/Configuration/configuration-api-keys.md
View file

@ -4,48 +4,26 @@ sidebar_position: 1
slug: /configuration-api-keys slug: /configuration-api-keys
--- ---
Langflow provides an API key functionality that allows users to access their individual components and flows without traditional login authentication. The API key is a user-specific token that can be included in the request header, query parameter, or as a command line argument to authenticate API calls. This documentation outlines how to generate, use, and manage API keys in Langflow.
:::info :::info
This page may contain outdated information. It will be updated as soon as possible. The default user and password are set using the LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD environment variables. The default values are `langflow` and `langflow`, respectively.
::: :::
## Generate an API key
Langflow provides an API key functionality that allows users to access their individual components and flows without traditional login authentication. The API key is a user-specific token that can be included in the request header or query parameter to authenticate API calls. This documentation outlines how to generate, use, and manage API keys in Langflow.
:::info
The default user and password are set using the LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD environment variables. The default values are langflow and langflow, respectively.
:::
## Generate an API key {#c29986a69cad4cdbbe7537e383ea7207}
Generate a user-specific token to use with Langflow. Generate a user-specific token to use with Langflow.
### Generate an API key with the Langflow UI
### Generate an API key with the Langflow UI {#3d90098ddd7c44b6836c0273acf57123} 1. Click your user icon and select **Settings**.
2. Click **Langflow API**, and then click **Add New**.
1. Click on the "API Key" icon. 3. Name your key, and then click **Create Secret Key**.
4. Copy the API key and store it in a secure location.
![](./596474918.png)
2. Click on "Create new secret key".
3. Give it an optional name.
4. Click on "Create secret key".
5. Copy the API key and store it in a secure location.
### Generate an API key with the Langflow CLI {#2368f62fc4b8477e8080c9c2d3659d76}
### Generate an API key with the Langflow CLI
```shell ```shell
langflow api-key langflow api-key
@ -64,148 +42,152 @@ python -m langflow api-key
``` ```
## Authenticate requests with the Langflow API key
## Use the Langflow API key {#ae787e4b0d3846aa9094fac75e0ac04f}
Include your API key in API requests to authenticate requests to Langflow. Include your API key in API requests to authenticate requests to Langflow.
### Include the API key in the HTTP header
### Use the `x-api-key` header {#70965b3ad24d467ca4f90e7c13a1f394} To use the API key when making API requests with cURL, include the API key in the HTTP header.
Include the `x-api-key` in the HTTP header when making API requests:
```shell ```shell
curl -X POST \\ curl -X POST \
<http://localhost:3000/api/v1/run/><your_flow_id> \\ "http://127.0.0.1:7860/api/v1/run/*`YOUR_FLOW_ID`*?stream=false" \
-H 'Content-Type: application/json'\\ -H 'Content-Type: application/json' \
-H 'x-api-key: <your api key>'\\ -H 'x-api-key: *`YOUR_API_KEY`*' \
-d '{"inputs": {"text":""}, "tweaks": {}}' -d '{"inputs": {"text":""}, "tweaks": {}}'
``` ```
To instead pass the API key as a query parameter, do the following:
With Python using `requests`: ```shell
curl -X POST \
"http://127.0.0.1:7860/api/v1/run/*`YOUR_FLOW_ID`*?x-api-key=*`YOUR_API_KEY`*?stream=false" \
-H 'Content-Type: application/json' \
-d '{"inputs": {"text":""}, "tweaks": {}}'
```
To use the API key when making API requests with the Python `requests` library, include the API key as a variable string.
```python ```python
import argparse
import json
from argparse import RawTextHelpFormatter
import requests import requests
from typing import Optional from typing import Optional
import warnings
try:
from langflow.load import upload_file
except ImportError:
warnings.warn("Langflow provides a function to help you upload files to the flow. Please install langflow to use it.")
upload_file = None
BASE_API_URL = "http://127.0.0.1:7860"
FLOW_ID = "*`YOUR_FLOW_ID`*"
ENDPOINT = "" # You can set a specific endpoint name in the flow settings
BASE_API_URL = "<http://localhost:3001/api/v1/process>"
FLOW_ID = "4441b773-0724-434e-9cee-19d995d8f2df"
# You can tweak the flow by adding a tweaks dictionary # You can tweak the flow by adding a tweaks dictionary
# e.g {"OpenAI-XXXXX": {"model_name": "gpt-4"}} # e.g {"OpenAI-XXXXX": {"model_name": "gpt-4"}}
TWEAKS = {} TWEAKS = {
"ChatInput-8a86T": {},
"Prompt-pKfl9": {},
"ChatOutput-WcGpD": {},
"OpenAIModel-5UyvQ": {}
}
def run_flow(inputs: dict, def run_flow(message: str,
flow_id: str, endpoint: str,
tweaks: Optional[dict] = None, output_type: str = "chat",
apiKey: Optional[str] = None) -> dict: input_type: str = "chat",
tweaks: Optional[dict] = None,
api_key: Optional[str] = None) -> dict:
""" """
Run a flow with a given message and optional tweaks. Run a flow with a given message and optional tweaks.
:param message: The message to send to the flow :param message: The message to send to the flow
:param flow_id: The ID of the flow to run :param endpoint: The ID or the endpoint name of the flow
:param tweaks: Optional tweaks to customize the flow :param tweaks: Optional tweaks to customize the flow
:return: The JSON response from the flow :return: The JSON response from the flow
""" """
api_url = f"{BASE_API_URL}/{flow_id}" api_url = f"{BASE_API_URL}/api/v1/run/{endpoint}"
payload = {"inputs": inputs}
headers = {}
payload = {
"input_value": message,
"output_type": output_type,
"input_type": input_type,
}
headers = None
if tweaks: if tweaks:
payload["tweaks"] = tweaks payload["tweaks"] = tweaks
if apiKey: if api_key:
headers = {"x-api-key": apiKey} headers = {"x-api-key": api_key}
response = requests.post(api_url, json=payload, headers=headers) response = requests.post(api_url, json=payload, headers=headers)
return response.json() return response.json()
# Setup any tweaks you want to apply to the flow def main():
inputs = {"text":""} parser = argparse.ArgumentParser(description="""Run a flow with a given message and optional tweaks.
api_key = "<your api key>" Run it like: python <your file>.py "your message here" --endpoint "your_endpoint" --tweaks '{"key": "value"}'""",
print(run_flow(inputs, flow_id=FLOW_ID, tweaks=TWEAKS, apiKey=api_key)) formatter_class=RawTextHelpFormatter)
parser.add_argument("message", type=str, help="The message to send to the flow")
parser.add_argument("--endpoint", type=str, default=ENDPOINT or FLOW_ID, help="The ID or the endpoint name of the flow")
parser.add_argument("--tweaks", type=str, help="JSON string representing the tweaks to customize the flow", default=json.dumps(TWEAKS))
parser.add_argument("--api_key", type=str, help="API key for authentication", default=None)
parser.add_argument("--output_type", type=str, default="chat", help="The output type")
parser.add_argument("--input_type", type=str, default="chat", help="The input type")
parser.add_argument("--upload_file", type=str, help="Path to the file to upload", default=None)
parser.add_argument("--components", type=str, help="Components to upload the file to", default=None)
args = parser.parse_args()
try:
tweaks = json.loads(args.tweaks)
except json.JSONDecodeError:
raise ValueError("Invalid tweaks JSON string")
if args.upload_file:
if not upload_file:
raise ImportError("Langflow is not installed. Please install it to use the upload_file function.")
elif not args.components:
raise ValueError("You need to provide the components to upload the file to.")
tweaks = upload_file(file_path=args.upload_file, host=BASE_API_URL, flow_id=args.endpoint, components=[args.components], tweaks=tweaks)
response = run_flow(
message=args.message,
endpoint=args.endpoint,
output_type=args.output_type,
input_type=args.input_type,
tweaks=tweaks,
api_key=args.api_key
)
print(json.dumps(response, indent=2))
if __name__ == "__main__":
main()
``` ```
To pass the API key to your script with a command line argument, do the following:
### Use the query parameter {#febb797f3bb5403b9f070afc0fa4f453}
Include the API key as a query parameter in the URL:
```shell ```shell
curl -X POST \\ python your_script.py "*`YOUR_INPUT_MESSAGE`*" --api_key "*`YOUR_API_KEY`*"
<http://localhost:3000/api/v1/process/><your_flow_id>?x-api-key=<your_api_key> \\
-H 'Content-Type: application/json'\\
-d '{"inputs": {"text":""}, "tweaks": {}}'
``` ```
## Security considerations
With Python using `requests`:
```python
import requests
BASE_API_URL = "<http://localhost:3001/api/v1/process>"
FLOW_ID = "4441b773-0724-434e-9cee-19d995d8f2df"
# You can tweak the flow by adding a tweaks dictionary
# e.g {"OpenAI-XXXXX": {"model_name": "gpt-4"}}
TWEAKS = {}
def run_flow(inputs: dict,
flow_id: str,
tweaks: Optional[dict] = None,
apiKey: Optional[str] = None) -> dict:
"""
Run a flow with a given message and optional tweaks.
:param message: The message to send to the flow
:param flow_id: The ID of the flow to run
:param tweaks: Optional tweaks to customize the flow
:return: The JSON response from the flow
"""
api_url = f"{BASE_API_URL}/{flow_id}"
payload = {"inputs": inputs}
headers = {}
if tweaks:
payload["tweaks"] = tweaks
if apiKey:
api_url += f"?x-api-key={apiKey}"
response = requests.post(api_url, json=payload, headers=headers)
return response.json()
# Setup any tweaks you want to apply to the flow
inputs = {"text":""}
api_key = "<your api key>"
print(run_flow(inputs, flow_id=FLOW_ID, tweaks=TWEAKS, apiKey=api_key))
```
## Security Considerations {#1273eb69a61344d19827b30dba46dfd5}
- **Visibility**: For security reasons, the API key cannot be retrieved again through the UI. - **Visibility**: For security reasons, the API key cannot be retrieved again through the UI.
- **Scope**: The key allows access only to the flows and components of the specific user to whom it was issued. - **Scope**: The key allows access only to the flows and components of the specific user to whom it was issued.
## Custom API endpoint {#da933a86690a4fdeac24024472caf8a9} ## Custom API endpoint
To choose a custom name for your API endpoint, select **Project Settings** &gt; **Endpoint Name** and name your endpoint.
Under **Project Settings** &gt; **Endpoint Name**, you can pick a custom name for the endpoint used to call your flow from the API. ## Revoke an API key
To revoke an API key, delete it from the the list of keys in the **Settings** menu.
## Revoke an API Key {#f0ea41ea167845cea91bb5e8f90d9df0} 1. Click your user icon and select **Settings**.
2. Click **Langflow API**.
3. Select the keys you want to delete and click the trash can icon.
This action immediately invalidates the key and prevents it from being used again.
To revoke an API key, delete it from the UI. This action immediately invalidates the key and prevents it from being used again.