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 para ver la lista completa de APIs públicas

Prediction

Create a new prediction

Create a new prediction

POST/prediction/{id}

Authorization

bearerAuth

Path parameters

id*string

Chatflow ID

Body

application/jsonmultipart/form-data

questionstring

The question being asked

overrideConfigobject

The configuration to override the default prediction settings (optional)

historyarray of object

The history messages to be prepended (optional)

uploadsarray of object

Response

200400404422500

Prediction created successfully

Body

application/json

textstring

The result of the prediction

jsonobject

The result of the prediction in JSON format if available

questionstring

The question asked during the prediction process

chatIdstring

The chat ID associated with the prediction

chatMessageIdstring

The chat message ID associated with the prediction

sessionIdstring

The session ID associated with the prediction

memoryTypestring

The memory type associated with the prediction

sourceDocumentsarray of object

usedToolsarray of object

fileAnnotationsarray of object

Request

JavaScriptCurlPythonHTTP

const response = await fetch('/prediction/{id}', {
    method: 'POST',
    headers: {
      "Authorization": "Bearer JWT",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({}),
});
const data = await response.json();

Response

200

{
  "text": "text",
  "question": "text",
  "chatId": "text",
  "chatMessageId": "text",
  "sessionId": "text",
  "memoryType": "text",
  "sourceDocuments": [
    {
      "pageContent": "This is the content of the page.",
      "metadata": {
        "author": "John Doe",
        "date": "2024-08-24"
      }
    }
  ],
  "usedTools": [
    {
      "tool": "Name of the tool",
      "toolInput": {
        "input": "search query"
      },
      "toolOutput": "text"
    }
  ],
  "fileAnnotations": [
    {
      "filePath": "path/to/file",
      "fileName": "file.txt"
    }
  ]
}

Usando Python/TS Library

Flowise proporciona 2 librerías:

• Python: pip install flowise

• Typescript: npm install flowise-sdk

Python SDK

from flowise import Flowise, PredictionData

def test_non_streaming():
    client = Flowise()

    # Test de predicción sin streaming
    completion = client.create_prediction(
        PredictionData(
            chatflowId="<chatflow-id>",
            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="<chatflow-id>",
            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()

Typescript SDK

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()

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.

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

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
    }
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

History

Puedes anteponer mensajes del historial para dar contexto al LLM. Por ejemplo, si quieres que el LLM recuerde el nombre del usuario:

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

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?"
        },
    ]
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

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.

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

def query(payload):
    response = requests.post(API_URL, json=payload)
    return response.json()
    
output = query({
    "question": "Hola, ¿cómo estás?",
    "overrideConfig": {
        "sessionId": "123"
    } 
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

Variables

Pasa variables en la API para ser utilizadas por los nodos en el flujo. Ver más: Variables

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

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"
        }
    }
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

Image Uploads

Cuando Allow Image Upload está habilitado, las imágenes pueden ser cargadas desde la interfaz de chat.

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

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'
        }
    ]
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

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.

Python API

import requests
API_URL = "http://localhost:3000/api/v1/prediction/<chatflowId>"

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'
        }
    ]
})

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/prediction/<chatflowId>",
        {
            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);
});

Vector Upsert API

Upsert vector embeddings

Upsert vector embeddings of documents in a chatflow

POST/vector/upsert/{id}

Authorization

bearerAuth

Path parameters

id*string

Chatflow ID

Body

application/jsonmultipart/form-data

stopNodeIdstring

In cases when you have multiple vector store nodes, you can specify the node ID to store the vectors

Example: "node_1"

overrideConfigobject

The configuration to override the default vector upsert settings (optional)

Response

200400404422500

Vector embeddings upserted successfully

Body

application/json

numAddednumber

Number of vectors added

Example: 1

numDeletednumber

Number of vectors deleted

Example: 1

numUpdatednumber

Number of vectors updated

Example: 1

numSkippednumber

Number of vectors skipped (not added, deleted, or updated)

Example: 1

addedDocsarray of object

Request

JavaScriptCurlPythonHTTP

const response = await fetch('/vector/upsert/{id}', {
    method: 'POST',
    headers: {
      "Authorization": "Bearer JWT",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({}),
});
const data = await response.json();

Response

200

{
  "numAdded": 1,
  "numDeleted": 1,
  "numUpdated": 1,
  "numSkipped": 1,
  "addedDocs": [
    {
      "pageContent": "This is the content of the page.",
      "metadata": {
        "author": "John Doe",
        "date": "2024-08-24"
      }
    }
  ]
}

Document Loaders with File Upload

Algunos document loaders en Flowise permiten al usuario cargar archivos:

• CSV File

• Docx File

• Json File

• Json Lines File

• PDF File

• Text File

• Unstructured File

Si el flujo contiene Document Loaders 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 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.

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

Python API

import requests

API_URL = "http://localhost:3000/api/v1/vector/upsert/<chatflowId>"

# 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)

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/<chatflowId>",
        {
            method: "POST",
            body: formData
        }
    );
    const result = await response.json();
    return result;
}

query(formData).then((response) => {
    console.log(response);
});

Document Loaders without Upload

For other Document Loaders nodes without Upload File functionality, the API body is in JSON format similar to Prediction API.

Python API

import requests

API_URL = "http://localhost:3000/api/v1/vector/upsert/<chatflowId>"

def query(payload):
    response = requests.post(API_URL, json=payload)
    print(response)
    return response.json()

output = query({
    "overrideConfig": { # optional
        "returnSourceDocuments": true
    }
})
print(output)

Javascript API

async function query(data) {
    const response = await fetch(
        "http://localhost:3000/api/v1/vector/upsert/<chatflowId>",
        {
            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);
});

Document Upsert/Refresh API

Refer to Document Stores section for more information about how to use the API.

Upsert new document to document store

Upsert new document to document store

POST/document-store/upsert/{id}

Authorization

bearerAuth

Path parameters

id*string (uuid)

Document store ID

Body

application/jsonmultipart/form-data

docIdstring (uuid)

Document ID within the store. If provided, existing configuration from the document will be used for the new document

loaderobject

splitterobject

embeddingobject

vectorStoreobject

recordManagerobject

Response

200400500

Successfully execute upsert operation

Body

application/json

numAddednumber

Number of vectors added

Example: 1

numDeletednumber

Number of vectors deleted

Example: 1

numUpdatednumber

Number of vectors updated

Example: 1

numSkippednumber

Number of vectors skipped (not added, deleted, or updated)

Example: 1

addedDocsarray of object

Request

JavaScriptCurlPythonHTTP

const response = await fetch('/document-store/upsert/{id}', {
    method: 'POST',
    headers: {
      "Authorization": "Bearer JWT",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({}),
});
const data = await response.json();

Response

200

{
  "numAdded": 1,
  "numDeleted": 1,
  "numUpdated": 1,
  "numSkipped": 1,
  "addedDocs": [
    {
      "pageContent": "This is the content of the page.",
      "metadata": {
        "author": "John Doe",
        "date": "2024-08-24"
      }
    }
  ]
}

Re-process and upsert all documents in document store

Re-process and upsert all existing documents in document store

POST/document-store/refresh/{id}

Authorization

bearerAuth

Path parameters

id*string (uuid)

Document store ID

Body

application/json

itemsarray of object

Response

200400500

Successfully execute refresh operation

Body

application/json

any

Request

JavaScriptCurlPythonHTTP

const response = await fetch('/document-store/refresh/{id}', {
    method: 'POST',
    headers: {
      "Authorization": "Bearer JWT",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({}),
});
const data = await response.json();

Video Tutorials

Those video tutorials cover the main use cases for implementing the Flowise API.