description |
---|
Learn more about the details of some of the most used APIs: prediction, vector-upsert |
Refer to API Reference for full list of public APIs
{% swagger src="../.gitbook/assets/swagger (1).yml" path="/prediction/{id}" method="post" %} swagger (1).yml {% endswagger %}
Flowise provides 2 libraries:
- Python:
pip install flowise
- Typescript:
npm install flowise-sdk
{% tabs %} {% tab title="Python SDK" %}
from flowise import Flowise, PredictionData
def test_non_streaming():
client = Flowise()
# Test non-streaming prediction
completion = client.create_prediction(
PredictionData(
chatflowId="<chatflow-id>",
question="What is the capital of France?",
streaming=False
)
)
# Process and print the response
for response in completion:
print("Non-streaming response:", response)
def test_streaming():
client = Flowise()
# Test streaming prediction
completion = client.create_prediction(
PredictionData(
chatflowId="<chatflow-id>",
question="Tell me a joke!",
streaming=True
)
)
# Process and print each streamed chunk
print("Streaming response:")
for chunk in completion:
print(chunk)
if __name__ == "__main__":
# Run non-streaming test
test_non_streaming()
# Run streaming test
test_streaming()
{% endtab %}
{% tab title="Typescript SDK" %}
import { FlowiseClient } from 'flowise-sdk'
async function test_streaming() {
const client = new FlowiseClient({ baseUrl: 'http://localhost:3000' });
try {
// For streaming prediction
const prediction = await client.createPrediction({
chatflowId: 'fe1145fa-1b2b-45b7-b2ba-bcc5aaeb5ffd',
question: 'What is the revenue of Apple?',
streaming: true,
});
for await (const chunk of prediction) {
console.log(chunk);
}
} catch (error) {
console.error('Error:', error);
}
}
async function test_non_streaming() {
const client = new FlowiseClient({ baseUrl: 'http://localhost:3000' });
try {
// For streaming prediction
const prediction = await client.createPrediction({
chatflowId: 'fe1145fa-1b2b-45b7-b2ba-bcc5aaeb5ffd',
question: 'What is the revenue of Apple?',
});
console.log(prediction);
} catch (error) {
console.error('Error:', error);
}
}
// Run non-streaming test
test_non_streaming()
// Run streaming test
test_streaming()
{% endtab %} {% endtabs %}
Override existing input configuration of the chatflow with overrideConfig property.
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hey, how are you?",
"overrideConfig": {
"sessionId": "123",
"returnSourceDocuments": true
}
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hey, how are you?",
"overrideConfig": {
"sessionId": "123",
"returnSourceDocuments": true
}
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
You can prepend history messages to give some context to LLM. For example, if you want the LLM to remember user's name:
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hey, how are you?",
"history": [
{
"role": "apiMessage",
"content": "Hello how can I help?"
},
{
"role": "userMessage",
"content": "Hi my name is Brian"
},
{
"role": "apiMessage",
"content": "Hi Brian, how can I help?"
},
]
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hey, how are you?",
"history": [
{
"role": "apiMessage",
"content": "Hello how can I help?"
},
{
"role": "userMessage",
"content": "Hi my name is Brian"
},
{
"role": "apiMessage",
"content": "Hi Brian, how can I help?"
},
]
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
You can pass a sessionId
to persists the state of the conversation, so the every subsequent API calls will have context about previous conversation. Otherwise, a new session will be generated each time.
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hey, how are you?",
"overrideConfig": {
"sessionId": "123"
}
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hey, how are you?",
"overrideConfig": {
"sessionId": "123"
}
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
Pass variables in the API to be used by the nodes in the flow. See more: Variables
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hey, how are you?",
"overrideConfig": {
"vars": {
"foo": "bar"
}
}
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hey, how are you?",
"overrideConfig": {
"vars": {
"foo": "bar"
}
}
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
When Allow Image Upload is enabled, images can be uploaded from chat interface.
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Can you describe the image?",
"uploads": [
{
"data": 'data:image/png;base64,iVBORw0KGgdM2uN0', # base64 string or url
"type": 'file', # file | url
"name": 'Flowise.png',
"mime": 'image/png'
}
]
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Can you describe the image?",
"uploads": [
{
"data": 'data:image/png;base64,iVBORw0KGgdM2uN0', //base64 string or url
"type": 'file', //file | url
"name": 'Flowise.png',
"mime": 'image/png'
}
]
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
When Speech to Text is enabled, users can speak directly into microphone and speech will be transcribed into text.
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatlfowid>"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"uploads": [
{
"data": 'data:audio/webm;codecs=opus;base64,GkXf', #base64 string
"type": 'audio',
"name": 'audio.wav',
"mime": 'audio/webm'
}
]
})
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"uploads": [
{
"data": 'data:audio/webm;codecs=opus;base64,GkXf', //base64 string
"type": 'audio',
"name": 'audio.wav',
"mime": 'audio/webm'
}
]
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
{% swagger src="../.gitbook/assets/swagger (1).yml" path="/vector/upsert/{id}" method="post" %} swagger (1).yml {% endswagger %}
Some document loaders in Flowise allow user to upload files:
If the flow contains Document Loaders with Upload File functionality, the API looks slightly different. Instead of passing body as JSON, form data is being used. This allows you to send files to the API.
{% hint style="info" %} Make sure the sent file type is compatible with the expected file type from document loader. For example, if a PDF File Loader is being used, you should only send .pdf files.
To avoid having separate loaders for different file types, we recommend to use File Loader {% endhint %}
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/vector/upsert/<chatlfowid>"
# use form data to upload files
form_data = {
"files": ('state_of_the_union.txt', open('state_of_the_union.txt', 'rb'))
}
body_data = {
"returnSourceDocuments": True
}
def query(form_data):
response = requests.post(API_URL, files=form_data, data=body_data)
print(response)
return response.json()
output = query(form_data)
print(output)
{% endtab %}
{% tab title="Javascript API" %}
// use FormData to upload files
let formData = new FormData();
formData.append("files", input.files[0]);
formData.append("returnSourceDocuments", true);
async function query(formData) {
const response = await fetch(
"http://localhost:3000/api/v1/vector/upsert/<chatlfowid>",
{
method: "POST",
body: formData
}
);
const result = await response.json();
return result;
}
query(formData).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
For other Document Loaders nodes without Upload File functionality, the API body is in JSON format similar to Prediction API.
{% tabs %} {% tab title="Python API" %}
import requests
API_URL = "http://localhost:3000/api/v1/vector/upsert/<chatlfowid>"
def query(form_data):
response = requests.post(API_URL, json=payload)
print(response)
return response.json()
output = query({
"overrideConfig": { # optional
"returnSourceDocuments": true
}
})
print(output)
{% endtab %}
{% tab title="Javascript API" %}
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/vector/upsert/<chatlfowid>",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"overrideConfig": { // optional
"returnSourceDocuments": true
}
}).then((response) => {
console.log(response);
});
{% endtab %} {% endtabs %}
Those video tutorials cover the main use cases for implementing the Flowise API.
{% embed url="https://youtu.be/9R5zo3IVkqU?si=y1v_aCQLE_70WBnA" %}
{% embed url="https://youtu.be/LhN560DhlzU" %}
{% embed url="https://youtu.be/kOwmPe8aLAA" %}