# API
### description: >- Aprende más sobre los detalles de algunas de las APIs más utilizadas: prediction, vector-upsert
## API
Consulta la [Referencia de API](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/api-reference/README.md) para ver la lista completa de APIs públicas
### Prediction
{% openapi src="/files/o4rPNaadRQ2pmGyLK00i" path="/prediction/{id}" method="post" %}
[swagger (1) (1) (1).yml](https://4068692976-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUiD7nOmFRK805sNuiieJ%2Fuploads%2Fgit-blob-9e347ad5c0ba6681019050ae693598cbc1f715a9%2Fswagger%20\(1\)%20\(1\)%20\(1\).yml?alt=media)
{% endopenapi %}
#### Usando Python/TS Library
Flowise proporciona 2 librerías:
* [Python](https://pypi.org/project/flowise/): `pip install flowise`
* [Typescript](https://www.npmjs.com/package/flowise-sdk): `npm install flowise-sdk`
{% tabs %}
{% tab title="Python SDK" %}
```python
from flowise import Flowise, PredictionData
def test_non_streaming():
client = Flowise()
# Test de predicción sin streaming
completion = client.create_prediction(
PredictionData(
chatflowId="",
question="¿Cuál es la capital de Francia?",
streaming=False
)
)
# Procesar e imprimir la respuesta
for response in completion:
print("Respuesta sin streaming:", response)
def test_streaming():
client = Flowise()
# Test de predicción con streaming
completion = client.create_prediction(
PredictionData(
chatflowId="",
question="¡Cuéntame un chiste!",
streaming=True
)
)
# Procesar e imprimir cada fragmento del stream
print("Respuesta con streaming:")
for chunk in completion:
print(chunk)
if __name__ == "__main__":
# Ejecutar test sin streaming
test_non_streaming()
# Ejecutar test con streaming
test_streaming()
```
{% endtab %}
{% tab title="Typescript SDK" %}
```javascript
import { FlowiseClient } from 'flowise-sdk'
async function test_streaming() {
const client = new FlowiseClient({ baseUrl: 'http://localhost:3000' });
try {
// Para predicción con streaming
const prediction = await client.createPrediction({
chatflowId: 'fe1145fa-1b2b-45b7-b2ba-bcc5aaeb5ffd',
question: '¿Cuál es el ingreso de 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 {
// Para predicción sin streaming
const prediction = await client.createPrediction({
chatflowId: 'fe1145fa-1b2b-45b7-b2ba-bcc5aaeb5ffd',
question: '¿Cuál es el ingreso de Apple?',
});
console.log(prediction);
} catch (error) {
console.error('Error:', error);
}
}
// Ejecutar test sin streaming
test_non_streaming()
// Ejecutar test con streaming
test_streaming()
```
{% endtab %}
{% endtabs %}
#### Override Config
Sobrescribe la configuración de entrada existente del chatflow con la propiedad **overrideConfig**.
Por razones de seguridad, la sobrescritura de configuración está deshabilitada por defecto. El usuario debe habilitarla yendo a **Chatflow Configuration** -> pestaña **Security**. Luego seleccionar la propiedad que puede ser sobrescrita.
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/prediction/"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"sessionId": "123",
"returnSourceDocuments": true
}
})
```
{% endtab %}
{% tab title="Javascript API" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"sessionId": "123",
"returnSourceDocuments": true
}
}).then((response) => {
console.log(response);
});
```
{% endtab %}
{% endtabs %}
#### History
Puedes anteponer mensajes del historial para dar contexto al LLM. Por ejemplo, si quieres que el LLM recuerde el nombre del usuario:
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/prediction/"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hola, ¿cómo estás?",
"history": [
{
"role": "apiMessage",
"content": "¿Hola, en qué puedo ayudarte?"
},
{
"role": "userMessage",
"content": "Hola, mi nombre es Brian"
},
{
"role": "apiMessage",
"content": "Hola Brian, ¿en qué puedo ayudarte?"
},
]
})
```
{% endtab %}
{% tab title="Javascript API" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hola, ¿cómo estás?",
"history": [
{
"role": "apiMessage",
"content": "¿Hola, en qué puedo ayudarte?"
},
{
"role": "userMessage",
"content": "Hola, mi nombre es Brian"
},
{
"role": "apiMessage",
"content": "Hola Brian, ¿en qué puedo ayudarte?"
},
]
}).then((response) => {
console.log(response);
});
```
{% endtab %}
{% endtabs %}
#### Persists Memory
Puedes pasar un `sessionId` para persistir el estado de la conversación, de modo que cada llamada API posterior tendrá contexto sobre la conversación anterior. De lo contrario, se generará una nueva sesión cada vez.
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/prediction/"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"sessionId": "123"
}
})
```
{% endtab %}
{% tab title="Javascript API" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"sessionId": "123"
}
}).then((response) => {
console.log(response);
});
```
{% endtab %}
{% endtabs %}
#### Variables
Pasa variables en la API para ser utilizadas por los nodos en el flujo. Ver más: [Variables](#variables)
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/prediction/"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"vars": {
"foo": "bar"
}
}
})
```
{% endtab %}
{% tab title="Javascript API" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "Hola, ¿cómo estás?",
"overrideConfig": {
"vars": {
"foo": "bar"
}
}
}).then((response) => {
console.log(response);
});
```
{% endtab %}
{% endtabs %}
#### Image Uploads
Cuando **Allow Image Upload** está habilitado, las imágenes pueden ser cargadas desde la interfaz de chat.
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/prediction/"
def query(payload):
response = requests.post(API_URL, json=payload)
return response.json()
output = query({
"question": "¿Puedes describir la imagen?",
"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" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/prediction/",
{
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
}
);
const result = await response.json();
return result;
}
query({
"question": "¿Puedes describir la imagen?",
"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 %}
#### Speech to Text
Cuando **Speech to Text** está habilitado, los usuarios pueden hablar directamente en el micrófono y la voz se transcribirá en texto.
Si el flujo contiene [Document Loaders](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/integrations/langchain/document-loaders/README.md) con la funcionalidad de carga de archivo, la API se ve ligeramente diferente. En lugar de pasar el cuerpo como JSON, **form data** se utiliza. Esto te permite enviar archivos a la API. If the flow contains [Document Loaders](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/integrations/langchain/document-loaders/README.md) 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](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/integrations/langchain/document-loaders/file-loader.md)
{% endhint %}
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/vector/upsert/"
# 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" %}
```javascript
// 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/",
{
method: "POST",
body: formData
}
);
const result = await response.json();
return result;
}
query(formData).then((response) => {
console.log(response);
});
```
{% endtab %}
{% endtabs %}
#### Document Loaders without Upload
For other [Document Loaders](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/integrations/langchain/document-loaders/README.md) nodes without Upload File functionality, the API body is in **JSON** format similar to [Prediction API](#prediction-api).
{% tabs %}
{% tab title="Python API" %}
```python
import requests
API_URL = "http://localhost:3000/api/v1/vector/upsert/"
def query(payload):
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" %}
```javascript
async function query(data) {
const response = await fetch(
"http://localhost:3000/api/v1/vector/upsert/",
{
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 %}
### Document Upsert/Refresh API
Refer to [Document Stores](https://github.com/FlowiseAI/FlowiseDocs/blob/main/esp/usar-flowise/document-stores.md#id-10.-api) section for more information about how to use the API.
{% openapi src="/files/1BTK1xdXP3s2ojlHaeC1" path="/document-store/upsert/{id}" method="post" %}
[swagger (2).yml](https://4068692976-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUiD7nOmFRK805sNuiieJ%2Fuploads%2Fgit-blob-ad9b5e4b876afbdb6413161795f3853868ba28d9%2Fswagger%20\(2\).yml?alt=media)
{% endopenapi %}
{% openapi src="/files/1BTK1xdXP3s2ojlHaeC1" path="/document-store/refresh/{id}" method="post" %}
[swagger (2).yml](https://4068692976-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUiD7nOmFRK805sNuiieJ%2Fuploads%2Fgit-blob-ad9b5e4b876afbdb6413161795f3853868ba28d9%2Fswagger%20\(2\).yml?alt=media)
{% endopenapi %}
### Video Tutorials
Those video tutorials cover the main use cases for implementing the Flowise API.
{% embed url="" %}
{% embed url="" %}
{% embed url="" %}
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.flowiseai.com/espanol/documentacion-oficial/usar-flowise/api.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.