预测

Prediction API是与您的Flowise流程和助手交互的主要端点。它允许您向所选流程发送消息并接收回复。此API处理核心聊天功能，包括：

聊天互动：向您的流程发送问题或消息，并接收由AI生成的回复
流式响应：获取实时流式响应，以提供更佳的用户体验
对话记忆：保持会话中多条消息之间的上下文连贯性
文件处理：上传并处理图像、音频和其他文件，作为查询的一部分
动态配置：在运行时覆盖聊天流程设置并传递变量

如需了解详情，请参阅预测端点API参考。

基本URL和认证

基础网址：http://localhost:3000（或您的Flowise实例网址）

端点：POST /api/v1/prediction/:id

认证：请参阅流程认证

请求格式

基本请求结构


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
    “问题”：“请在此处输入您的问题”，
    "streaming": false,，
    "overrideConfig": {},，
    "history": []，
    "uploads": []，
    "form": {}
}

参数

类型

必填

描述

question

string

是

要发送到流程的消息/问题

form

object

或者是 question 或者是 form

要发送到流程中的表单对象

streaming

boolean

否

启用流式响应（默认值：false）

overrideConfig

object

否

覆盖流程配置

history

array

否

先前的对话消息

uploads

array

否

要上传的文件（图像、音频等）

humanInput

object

否

返回人类反馈并继续执行

SDK库

Flowise为Python和TypeScript/JavaScript提供了官方SDK：

安装

Python：pip install flowise

TypeScript/JavaScript：npm install flowise-sdk

Python SDK使用方法

标签页

python 从flowise导入Flowise和PredictionData

初始化客户端

客户端 = Flowise(base_url="http://localhost:3000")

非流式预测

尝试：响应 = 客户端.创建预测( 预测数据( chatflowId="你的聊天流程ID",，问题="什么是机器学习？",，流式传输=否 ) )

# 处理响应
对于响应中的结果：
    打印（“响应：”，结果）

除了 Exception 异常（用 e 表示）：打印(f"错误：{e}")

{% endtab %}

{% tab title="流媒体" %}
python
从flowise导入Flowise和PredictionData

客户端 = Flowise(base_url="http://localhost:3000")

# 流式预测
尝试：
    响应 = 客户端.创建预测(
        预测数据(
            chatflowId="你的聊天流程ID",，
            问题：“给我讲一个关于人工智能的长故事。”，
            流式传输=True
        )
    )
    
    # 处理流式数据块
    打印（“流式响应：”）
    对于响应中的每个块：
        print(chunk, end="", flush=True)
        
除了 Exception 异常（用 e 表示）：
    打印(f"错误：{e}")

python 从flowise导入Flowise和PredictionData

客户端 = Flowise(base_url="http://localhost:3000")

高级配置

尝试：响应 = 客户端.创建预测( 预测数据( chatflowId="你的聊天流程ID",，问题="分析这些数据"， streaming=False,， overrideConfig = { "sessionId": "user-session-123",， "temperature": 0.7,， "最大标记数（maxTokens）": 500,， "returnSourceDocuments": True } ) )

对于响应中的结果：
    打印("响应：", result)

除了 Exception 异常（用 e 表示）：打印(f"错误：{e}")

{% endtab %}
{% endtabs %}

#### TypeScript/JavaScript SDK使用方法

标签页
{% tab title="基本用法" %}
```typescript

/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
从'flowise-sdk'导入{FlowiseClient}；

// 初始化客户端
const client = new FlowiseClient({
    基本网址：'http://localhost:3000'
});

// 非流式预测
异步函数 chatWithFlow() {
    尝试 {
        const response = await client.createPrediction({
            chatflowId: '你的聊天流程ID',，
            问题：“什么是机器学习？”，
            流式传输：否
        });
        
        console.log('响应:', response);；
        
    } catch (error) {
        console.error('错误:', error);；
    }
}

使用流程聊天();；

{% endtab %}

{% tab title="流媒体" %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
从 'flowise-sdk' 导入 {FlowiseClient}；

const client = new FlowiseClient({
    基本网址：'http://localhost:3000'
});

// 流式预测
异步函数 streamingChat() {
    尝试 {
        const stream = await client.createPrediction({
            chatflowId: '你的聊天流程ID',，
            问题：“给我讲一个关于人工智能的长故事。”，
            流式传输：是
        });
        
        控制台输出：“流式响应：”；
        对于流中的每个块（chunk），执行以下操作：
            process.stdout.write(chunk);；
        }
        
    } catch (error) {
        console.error('错误:', error);；
    }
}

streamingChat();；

{% endtab %}

{% tab title="配置方式" %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
你是个专业的翻译，负责把英语内容翻译成中文内容，请帮我翻译一下原文内容
从'flowise-sdk'导入{FlowiseClient}；

const client = new FlowiseClient({
    基础网址：'http://localhost:3000'
});

// 高级配置
异步函数 advancedChat() {
    尝试 {
        const response = await client.createPrediction({
            chatflowId: '你的聊天流程ID',，
            问题：'分析这些数据'，
            流式传输：否，
            overrideConfig: {
                会话ID: 'user-session-123',，
                温度：0.7，
                最大标记数：500，
                返回源文档：是
            }
        });
        
        console.log('响应:', response);；
        
    } catch (error) {
        console.error('错误:', error);；
    }
}

调用高级聊天函数；

{% endtab %} {% endtabs %}

直接使用HTTP API

如果您更倾向于直接使用REST API而不使用SDK：

基本请求

选项卡 {% tab title="Python (requests)" %} python 导入requests库导入json库

def send_message(chatflow_id, question, streaming=False): url = f"http://localhost:3000/api/v1/prediction/{chatflow_id}"

载荷 = {
    "question": 问题，
    "streaming": 流媒体
}

头信息 = {
    "Content-Type": "application/json"
}

尝试：
    响应 = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()  # 针对错误的状态码抛出异常
    
    返回响应的JSON格式数据
    
除了requests.exceptions.RequestException异常（用e表示）之外：
    打印(f"请求失败：{e}")

返回空值

用法

结果 = 发送消息( chatflow_id="你的聊天流程ID",，问题：“什么是人工智能？”，流式传输=否 )

如果结果为：打印("响应：", result)


</div>

<div data-gb-custom-block data-tag="tab" data-title='JavaScript (fetch)'>

```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
异步函数 sendMessage(chatflowId, question, streaming = false) {
    const url = `http://localhost:3000/api/v1/prediction/${chatflowId}`;；
    
    const payload = {
        问题：问题，
        流媒体：流媒体
    };
    
    尝试 {
        const response = await fetch(url, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        const result = await response.json();；
        返回结果；
        
    } catch (error) {
        console.error('请求失败:', error);；
        返回null；
    }
}

// 用法
sendMessage(
    'your-chatflow-id'，
    “什么是人工智能？”，
错误的
).then(result => {
    如果 (result) {
        console.log('响应:', result);；
    }
});

使用curl工具，通过POST方法，向http://localhost:3000/api/v1/prediction/your-chatflow-id发送请求
  -H "Content-Type: application/json" \
d
    “问题”：“什么是人工智能？”，
    "streaming": 否
  }'

高级功能

表单输入

在Agentflow V2中，您可以选择“表单”作为输入类型。

您可以通过表单输入的变量名称来覆盖该值


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
    "form": {
        "title": "示例",，
        "count": 1,，
        ...
    }
}

选项卡

python 导入 requests 库

def prediction(flow_id, form): url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

载荷 = {
    "form": 表单
}

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了requests.exceptions.RequestException异常（用e表示）之外：
    打印(f"错误：{e}")

返回空值

结果 = 预测( flow_id="你的流程ID",，表单 = { "title": "ABC",， “选项”为“A” } )

打印结果

{% endtab %}

{% tab title="JavaScript" %}
```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
异步函数 prediction(flowId, form) {
    const url = `http://localhost:3000/api/v1/prediction/${flowId}`;；
    
    const payload = {
        表单：表单
    };
    
    尝试 {
        const response = await fetch(url, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回 null；
    }
}

预测（
    'your-flow-id'，
    {
        "title": "ABC",，
        “选项”为“A”
    }
).then(result => {
    控制台输出（console.log）结果；
});

{% endtab %} {% endtabs %}

配置覆盖

动态覆盖聊天流程设置。

出于安全考虑，覆盖配置默认是禁用的。请从右上角启用：设置→配置→安全选项卡：

标签页 {% tab title="Python" %} python 导入requests库

def query_with_config(flow_id, question, config): url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

载荷 = {
    "question": 问题，
    "overrideConfig": 配置
}

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了 requests.exceptions.RequestException 异常之外，如果发生其他异常 e：
    打印(f"错误：{e}")

返回空值

示例：覆盖会话并返回源文档

结果 = 使用配置查询( flow_id="你的流程ID",，问题="机器学习是如何工作的？",，配置 = { "sessionId": "user-123",， "temperature": 0.5,， "最大标记数": 1000 } )

打印结果


</div>

<div data-gb-custom-block data-tag="tab" data-title='JavaScript'>

```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
你是个专业的翻译，负责把英语内容翻译成中文内容，请帮我翻译一下原文内容
异步函数 queryWithConfig(flowId, question, config) {
    const url = `http://localhost:3000/api/v1/prediction/${flowId}`;；
    
    const payload = {
        问题：问题，
        overrideConfig: 配置
    };
    
    尝试 {
        const response = await fetch(url, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 示例：覆盖会话并返回源文档
带配置的查询(
    'your-flow-id'，
    “机器学习是如何工作的？”，
    {
        会话ID: 'user-123'，
        温度：0.5，
        最大标记数：1000
    }
).then(result => {
    控制台输出（console.log）结果；
});

对于“array”类型，将鼠标悬停在信息图标上会显示可覆盖的模式。

overrideConfig 中的数组值将与现有数组值进行合并。例如，如果现有的 startState 为：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
  "key": "key1",，
  "value": "value1"
}

如果我们启用覆盖功能：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
"overrideConfig": {
    "startState": [
        {
            "key": "foo",，
            "value": "bar"
        }
    ],
    "llmMessages": [
        {
            "role": "系统",，
            “内容”：“你是个得力的助手”
        }
    ]
}

最终的startState将是：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
[
  {
    "key": "key1",，
    "value": "value1"
  },
  {
    "key": "foo",，
    "value": "bar"
  },
]

覆盖特定节点

默认情况下，如果多个节点共享同一类型且未指定节点ID，则覆盖属性将更新所有匹配节点的该属性。

例如，我想在两个LLM节点上覆盖系统消息：

在启用覆盖功能后：

我可以这样覆盖两个大型语言模型（LLM）的系统消息：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
"overrideConfig": {
    "llmMessages": [
        {
            "role": "系统",，
            “内容”：“你真是讽刺”
        }
    ]
}

从执行结果中，你可以看到被覆盖的系统消息：

在某些情况下，你可能只想覆盖特定节点的配置。你可以通过在想要覆盖的属性中指定节点ID来实现这一点。

例如：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
"overrideConfig": {
    "llmMessages": {
        "llmAgentflow_0": [
            {
                "role": "系统",，
                “内容”：“你很贴心”
            } 
        ],
        "llmAgentflow_1": [
            {
                "role": "系统",，
                "content": "你很聪明"
            } 
        ]
    }
}

如果你返回至Execution，你可以看到每个LLM（大型语言模型）都有正确的覆盖值：

对话历史

通过在历史记录数组中包含之前的消息来提供对话上下文。

历史消息格式


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
    "role": "api消息" | "用户消息",，
    "content": "消息内容"
}

选项卡

python 导入requests库

def chat_with_history(flow_id, question, history): url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

载荷 = {
    "question": 问题，
    “history”：历史
}

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了 requests.exceptions.RequestException 异常（用 e 表示）：
    打印(f"错误：{e}")

返回空值

带有上下文的对话示例

对话历史 = [ { "role": "apiMessage",， “内容”：“你好！我是AI助手。今天我能帮你什么吗？” }, { "role": "userMessage",， “内容”：“嗨，我叫莎拉，我正在学习人工智能。” }, { "role": "apiMessage",， “内容”：“很高兴认识你，Sarah！我很乐意帮助你了解人工智能。你对哪些具体方面感兴趣？” } ]

结果 = chat_with_history( flow_id="你的流程ID",，问题：“你能用简单的语言解释一下神经网络吗？”，历史记录=对话历史 )

打印结果

{% endtab %}

{% tab title="JavaScript" %}
```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
异步函数 chatWithHistory(flowId, question, history) {
    const url = `http://localhost:3000/api/v1/prediction/${flowId}`;；
    
    const payload = {
        问题：问题，
        历史：历史
    };
    
    尝试 {
        const response = await fetch(url, {
            方法：'POST'，
            头部信息：{
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新的错误（`HTTP 错误！状态：${response.status}`）；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 带有上下文的对话示例
const conversationHistory = [
    {
        角色："apiMessage"，
        内容：“你好！我是AI助手。今天我能帮你什么吗？”
    },
    {
        角色：“用户消息”，
        内容：“嗨，我叫莎拉，我正在学习人工智能。”
    },
    {
        角色：“apiMessage”，
        内容：“很高兴认识你，Sarah！我很乐意帮助你了解人工智能。你对哪些具体方面感兴趣？”
    }
];

聊天历史（
    'your-flow-id'，
    “你能用简单的话解释一下神经网络吗？”，
对话历史
).then(result => {
    控制台输出结果：console.log(result);；
});

{% endtab %} {% endtabs %}

会话管理

使用sessionId来在多个API调用之间维护会话状态。每个会话都维护其自己的会话上下文和内存。

选项卡 {% tab title="Python" %} python 导入requests库

类 FlowiseSession： __init__方法（构造函数）接受四个参数：flow_id、session_id、base_url和可选参数default_url。其中，flow_id和session_id是必填参数，base_url默认为http://localhost:3000 self.flow_id = flow_id self.session_id = session_id self.base_url = base_url self.url = f"{base_url}/api/v1/prediction/{flow_id}"

def send_message(self, question, **kwargs):
    载荷 = {
        "question": 问题，
        "overrideConfig": {
            "sessionId": self.session_id,，
            **kwargs.get("overrideConfig", {})
        }
    }
    
    # 添加任何其他参数
    对于kwargs中的每个键值对（key, value）：
        如果 key 不等于 "overrideConfig"：
            有效载荷[键] = 值
    
    尝试：
        响应 = requests.post(self.url, json=payload)
        响应.raise_for_status()
        返回响应的JSON格式数据
    除了 requests.exceptions.RequestException 异常之外，如果发生其他异常 e：
        打印(f"错误：{e}")

返回空值

用法

session = FlowiseSession( flow_id="你的流程ID",，会话ID="用户会话-123" )

第一条消息

响应1 = 会话.发送消息("你好，我叫约翰") 打印("响应1：", response1)

第二条消息 - 会记住之前的上下文

响应2 = 会话.发送消息("我的名字是什么？") print("响应2：", response2)


</div>

<div data-gb-custom-block data-tag="tab" data-title='JavaScript'>

```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
类 FlowiseSession {
    构造函数(flowId, sessionId, baseUrl = 'http://localhost:3000') {
        this.flowId = flowId;；
        this.sessionId = sessionId;；
        this.baseUrl = baseUrl;；
        this.url = `${baseUrl}/api/v1/prediction/${flowId}`;；
    }
    
    async sendMessage(question) {
        const payload = {
            问题：问题，
            overrideConfig: {
                会话ID：this.sessionId
            }
        };
  
        尝试 {
            const response = await fetch(this.url, {
                方法：'POST'，
                头信息：{
                    'Content-Type': 'application/json',，
                },
                正文：JSON.stringify(payload)
            });
            
            如果 (!response.ok) {
                抛出新错误(`HTTP 错误！状态：${response.status}`);；
            }
            
            返回 await response.json();；
            
        } catch (error) {
            console.error('错误:', error);；
            返回null；
        }
    }
}

// 用法
const session = new FlowiseSession(
    'your-flow-id'，
    “user-session-123”
);

异步函数 conversationExample() {
    // 第一条消息
    const response1 = await session.sendMessage("你好，我叫约翰");；
    console.log("响应1：", response1);；

    // 第二条消息 - 将记住之前的上下文
    const response2 = await session.sendMessage("What's my name?");；
    console.log("响应2：", response2);；
}

对话示例();；

变量

使用overrideConfig中的vars属性将动态变量传递给您的流程。您可以在流程中使用这些变量来注入动态内容。

{% 提示样式="警告" %} 在覆盖变量之前，必须先创建它。请参阅变量 {% 结束提示 %}

选项卡

python 导入 requests 库

def send_with_variables(flow_id, question, variables): url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

载荷 = {
    "question": 问题，
    "overrideConfig": {
        "vars": 变量
    }
}

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了requests.exceptions.RequestException异常（用e表示）之外：
    打印(f"错误：{e}")

返回空值

示例：传递用户信息和偏好

结果 = send_with_variables( flow_id="你的流程ID",，问题：“制定一个个性化的锻炼计划。”，变量 = { "user_name": "Alice",， "fitness_level": "中级",， "preferred_duration": "30分钟",， “设备”：“哑铃，弹力带”， “目标”：“力量训练，柔韧性” } )

打印(result)

{% endtab %}

{% tab title="JavaScript" %}
```javascript

/// 译文内容：
---
根据上面的信息，执行如下指令：
你是个专业的翻译，负责把英语内容翻译成中文内容，请帮我翻译一下原文内容
异步函数 sendWithVariables(flowId, question, variables) {
    const url = `http://localhost:3000/api/v1/prediction/${flowId}`;；

    const payload = {
        问题：问题，
        overrideConfig: {
            vars: 变量
        }
    };

    尝试 {
        const response = await fetch(url, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            主体：JSON.stringify(有效载荷)
        });

        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }

        返回 await response.json();；

    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 示例：传递用户信息和偏好设置
sendWithVariables(
    'your-flow-id'，
    “制定一个个性化的锻炼计划”，
    {
        用户名：'Alice'，
        健身水平：'中级'，
        preferred_duration: '30分钟',，
        设备：哑铃、弹力带，
        目标：'力量训练，柔韧性训练'
    }
).then(result => {
    控制台输出（console.log）结果；
});

{% endtab %} {% endtabs %}

图片上传

当您的流程支持图像处理时，请上传图像以进行视觉分析。更多参考信息，请参阅图像。

上传结构：


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
    "data": ""，
    "type": "未知类型",，
    "name": "，
    "mime": "
}

**数据：**图像的Base64编码或URL

类型：url 或 file

名称： 图片名称

Mime：image/png、image/jpeg、image/jpg

标签页 {% tab title="Python (Base64)" %} python 导入requests库导入base64模块导入操作系统

def upload_image(flow_id, question, image_path): # 读取并编码图像使用 open() 函数打开指定路径的图像文件，并以 'rb' 模式（即二进制读取模式）读取：编码图像 = base64.b64encode(图像文件.读取())的解码结果('utf-8')

# 根据文件扩展名确定 MIME 类型
mime_types = {
    '.png': 'image/png',，
    '.jpg': 'image/jpeg',，
    '.jpeg': 'image/jpeg',，
    '.gif': 'image/gif',，
    '.webp'：'image/webp'
}

文件扩展名 = os.path.splitext(图像路径)[1].lower()
mime_type = mime_types.get(file_ext, 'image/png')

url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

载荷 = {
    "question": 问题，
    "uploads": [
        {
            "data": f"数据：{mime_type}；base64，{encoded_image}"，
            "type": "文件",，
            "name": os.path.basename(image_path),，
            "mime": mime_type
        }
    ]
}

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了requests.exceptions.RequestException异常（用e表示）之外：
    打印(f"错误：{e}")

返回空值

使用示例

结果 = 上传图片( flow_id="你的流程ID",，问题="你能描述一下你在这张图片中看到了什么吗？",，图片路径="path/to/your/image.png" )

打印(result)


</div>

<div data-gb-custom-block data-tag="tab" data-title='Python (URL)'>
python
导入requests库
导入操作系统

def upload_image_url(flow_id, question, image_url, image_name=None):
    """
    使用URL而非base64编码来上传图片。
    对于已经在线存储的图像，这种方式更为高效。
    """
    url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

    # 如果未提供文件名，则从URL中提取
    如果没有 image_name：
        图片名称 = 图片URL中以斜杠分隔的最后一个元素
        如果图像名称中包含“?”：
            image_name = image_name.split('?')[0]

    # 根据URL扩展名确定MIME类型
    mime_types = {
        '.png': 'image/png',，
        '.jpg': 'image/jpeg',，
        '.jpeg': 'image/jpeg',，
        '.gif'：'image/gif'，
        '.webp'：'image/webp'
    }

    文件扩展名 = os.path.splitext(图像名称)[1].lower()
    mime_type = mime_types.get(file_ext, 'image/jpeg')

    有效载荷 = {
        "question": 问题，
        "uploads": [
            {
                "data": 图片URL，
                "type": "url",，
                "name": 图像名称，
                "mime": mime_type
            }
        ]
    }

    尝试：
        响应 = requests.post(url, json=payload)
        响应.raise_for_status()
        返回响应的JSON格式数据
    除了 requests.exceptions.RequestException 异常（用 e 表示）之外：
        打印(f"错误：{e}")
返回空值

# 使用公共图片URL的示例
结果 = 上传图片URL(
    flow_id="你的流程ID",，
    问题：“这张图片中有什么？请详细分析。”，
    图片URL为：“https://example.com/path/to/image.jpg”，
    图片名称="示例图片.jpg"
)

打印(result)

# 直接使用URL示例（无自定义名称）
result2 = upload_image_url(
    chatflow_id="你的聊天流程ID",，
    问题="描述这张截图",，
    图片链接="https://i.imgur.com/sample.png"
)

打印(result2)

{% endtab %}

{% tab title="JavaScript（文件上传）" %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
异步函数 uploadImage(flowId, question, imageFile) {
    返回一个新的Promise，该Promise的回调函数为((resolve, reject) => {
        const reader = new FileReader();；
        
        reader.onload = async function(e) {
            const base64Data = e.target.result;；
            
            const payload = {
                问题：问题，
                上传：[
                    {
                        数据：base64数据，
                        类型：'文件'，
                        名称：imageFile.name，
                        mime: imageFile.type
                    }
                ]
            };
            
            尝试 {
                const response = await fetch(`http://localhost:3000/api/v1/prediction/${flowId}`, {
                    方法：'POST'，
                    headers: {
                        'Content-Type': 'application/json',，
                    },
                    正文：JSON.stringify(payload)
                });
                
                如果 (!response.ok) {
                    抛出新的错误(`HTTP 错误！状态：${response.status}`);；
                }
                
                const result = await response.json();；
                解析（result）；
                
            } catch (error) {
                reject(error);；
            }
        };
        
        reader.onerror = function() {
            reject(new Error('读取文件失败'));；
        };
        
        reader.readAsDataURL(imageFile);；
    });
}

// 浏览器中的使用示例
document.getElementById('imageInput').addEventListener('change', async function(e) {
    const file = e.target.files[0];；
    如果 (file) {
        尝试 {
            const result = await uploadImage(
                'your-flow-id'，
                你能描述一下你在这张图片中看到了什么吗，
文件
            );
            console.log('分析结果:', result);；
        } catch (error) {
            console.error('上传失败:', error);；
        }
    }
});

{% endtab %}

{% tab title="JavaScript (URL)" %}

异步函数 uploadImageUrl(flowId, question, imageUrl, imageName = null) {
    /**
     * 使用URL而非base64编码来上传图片。
     * 对于已经在线托管的图片，这种方法更为高效。
     */
    
    // 如果未提供文件名，则从URL中提取
    如果 (!imageName) {
        imageName = imageUrl.split('/').pop();；
        如果 (imageName 包含 '?' 字符) {
            imageName = imageName.split('?')[0];；
        }
    }
    
    // 根据URL扩展名确定MIME类型
    const mimeTypes = {
        '.png': 'image/png',，
        '.jpg': 'image/jpeg',，
        '.jpeg': 'image/jpeg',，
        '.gif'：'image/gif'，
        '.webp'：'image/webp'
    };
    
    const fileExt = imageName.toLowerCase().substring(imageName.lastIndexOf('.'));；
    const mimeType = mimeTypes[fileExt] || 'image/jpeg';；
    
    const payload = {
        问题：问题，
        上传：[
            {
                数据：图片URL，
                类型：'url'，
                名称：imageName，
                mime: mimeType
            }
        ]
    };
    
    尝试 {
        const response = await fetch(`http://localhost:3000/api/v1/prediction/${flowId}`, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            主体：JSON.stringify(有效载荷)
        });
        
        如果 (!response.ok) {
            抛出新的错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 使用公共图片URL的示例
异步函数 analyzeImageFromUrl() {
    尝试 {
        const result = await uploadImageUrl(
            'your-flow-id'，
            这张图片中有什么？请详细分析一下，
            'https://example.com/path/to/image.jpg'，
            '示例图片.jpg'
        );
        
        console.log('分析结果：',result);；
    } catch (error) {
        console.error('上传失败:', error);；
    }
}

// 直接使用URL的示例（无自定义名称）
上传图片URL（
    'your-flow-id'，
    “描述这张截图”，
    “https://i.imgur.com/sample.png”
).then(result => {
    如果 (result) {
        console.log('分析结果:', result);；
    }
});

// 包含多个图片URL的示例
异步函数 analyzeMultipleImages() {
    const imageurls = [
        'https://example.com/image1.jpg'，
        'https://example.com/image2.png'，
        'https://example.com/image3.gif'
    ];
    
    const results = await Promise.all(
        imageurls.map(url =>
            上传图片URL（uploadImageUrl）
                'your-flow-id'，
                `分析此图片：${url}`，
网址
            )
        )
    );
    
    results.forEach((result, index) => {
        console.log(`第${index + 1}张图片分析结果：`, result);；
    });
}

{% endtab %}

{% tab title="JavaScript (Node.js)" %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
const fs = require('fs');；
const path = require('path');；

异步函数 uploadImage(flowId, question, imagePath) {
    // 读取图像文件
    const imageBuffer = fs.readFileSync(imagePath);；
    const base64Image = imageBuffer.toString('base64');；
    
    // 确定 MIME 类型
    const ext = path.extname(imagePath).toLowerCase();；
    const mimeTypes = {
        '.png': 'image/png',，
        '.jpg': 'image/jpeg',，
        '.jpeg': 'image/jpeg',，
        '.gif'：'image/gif'，
        '.webp'：'image/webp'
    };
    const mimeType = mimeTypes[ext] || 'image/png';；
    
    const payload = {
        问题：问题，
        上传：[
            {
                数据：`data:${mimeType};base64,${base64Image}`，
                类型：'文件'，
                名称：path.basename(imagePath)，
                mime: mimeType
            }
        ]
    };
    
    尝试 {
        const response = await fetch(`http://localhost:3000/api/v1/prediction/${flowId}`, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 使用示例
上传图片(
    'your-flow-id'，
    “你能描述一下你在这张图片中看到了什么吗？”，
    “path/to/your/image.png”
).then(result => {
    console.log('分析结果:', result);；
});

{% endtab %} {% endtabs %}

音频上传（语音转文字）

上传音频文件以进行语音转文字处理。更多参考信息，请参阅音频。

上传结构：


/// 译文内容：
---
根据上面的信息，执行如下指令：
您想翻译的文本可能是：
```json
{
  "query": "SELECT * FROM users WHERE username = 'admin'",
  "result": [
    {
      "id": 1,
      "username": "admin",
      "password": "admin"
    }
  ]
}

{ "data": ""， "type": "未知类型",， "name": "， "mime": " }


**数据：**音频的Base64编码或URL

**类型**：`url` 或 `file`

**名称：** 音频的名称

**Mime**：`audio/mp4`、`audio/webm`、`audio/wav`、`audio/mpeg`

选项卡
{% tab title="Python (Base64)" %}
python
导入requests库
导入base64模块
导入操作系统

def upload_audio(flow_id, audio_path, question=None):
    # 读取并编码音频
    使用 open(audio_path, 'rb') 打开音频文件，并使用 as 关键字将其赋值给 audio_file 变量：
        encoded_audio = base64.b64encode(audio_file.read()).decode('utf-8')
    
    # 根据文件扩展名确定 MIME 类型
    mime_types = {
        '.webm'：'audio/webm'，
        '.wav'：'audio/wav'，
        '.mp3'：'audio/mpeg'，
        '.m4a'：'audio/mp4'
    }
 
    文件扩展名 = os.path.splitext(音频路径)[1].lower()
    mime_type = mime_types.get(file_ext, 'audio/webm')
    
    url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
    
    载荷 = {
        "uploads": [
            {
                "data": f"数据：{mime_type}；base64，{encoded_audio}"，
                "type": "音频",，
                "name": os.path.basename(audio_path),，
                "mime": mime_type
            }
        ]
    }
    
    # 如果提供了问题，请添加
    如果问题：
        载荷["问题"] = 问题
    
    尝试：
        响应 = requests.post(url, json=payload)
        响应.raise_for_status()
        返回响应的JSON格式数据
    除了 requests.exceptions.RequestException 异常之外，如果发生其他异常 e：
        打印(f"错误：{e}")
返回空值

# 使用示例
结果 = 上传音频(
    flow_id="你的流程ID",，
    音频路径="path/to/your/audio.wav",，
    问题：“请转录这段音频并总结其内容。”
)

打印结果

python 导入requests库导入操作系统

def upload_audio_url(flow_id, audio_url, question=None, audio_name=None): """ 使用URL而非base64编码来上传音频文件。对于已经在线存储的音频文件来说，这种方式更为高效。 """ url = f"http://localhost:3000/api/v1/prediction/{flow_id}"

# 如果未提供文件名，则从URL中提取
如果没有 audio_name：
    音频名称 = 音频URL中以斜杠分隔的最后一个元素
    如果音频名称中包含“?”
        audio_name = audio_name.split('?')[0]

# 根据URL扩展名确定MIME类型
mime_types = {
    '.webm'：'audio/webm'，
    '.wav'：'audio/wav'，
    '.mp3'：'audio/mpeg'，
    '.m4a': 'audio/mp4',，
    '.ogg'：'audio/ogg'，
    '.aac'：'audio/aac'
}

文件扩展名 = os.path.splitext(音频名称)[1].lower()
mime_type = mime_types.get(file_ext, 'audio/wav')

有效载荷 = {
    "uploads": [
        {
            "data": 音频链接，
            "type": "url",，
            "name": audio_name,，
            "mime": mime_type
        }
    ]
}

# 如果提供了问题，请添加
如果问题：
    载荷["问题"] = 问题

尝试：
    响应 = requests.post(url, json=payload)
    响应.raise_for_status()
    返回响应的JSON格式数据
除了 requests.exceptions.RequestException 异常（用 e 表示）：
    打印(f"错误：{e}")

返回空值

使用公共音频URL的示例

结果 = 上传音频URL( flow_id="你的流程ID",，音频URL为："https://example.com/path/to/speech.mp3"，问题：“请转录这段音频并提供摘要。”，音频名称="语音录音.mp3" )

打印结果

直接使用URL的示例（无自定义名称或问题）

result2 = upload_audio_url( flow_id="你的流程ID",，音频URL为：“https://storage.googleapis.com/sample-audio/speech.wav” )

打印(result2)

会议转录示例

result3 = upload_audio_url( flow_id="你的流程ID",，音频链接="https://meetings.example.com/recording-123.m4a",，问题：“将这份会议录音转录出来，并提取出关键行动项和做出的决定。”，音频名称="team_meeting_jan15.m4a" )

打印(result3)

{% endtab %}

{% tab title="JavaScript（文件上传）" %}
```javascript
异步函数 uploadAudio(flowId, audioFile, question = null) {
    返回一个新的Promise，该Promise接受一个函数作为参数，该函数接受两个参数：resolve和reject
        const reader = new FileReader();；
        
        reader.onload = async function(e) {
            const base64Data = e.target.result;；
            
            const payload = {
                上传：[
                    {
                        数据：base64数据，
                        类型：'音频'，
                        名称：audioFile.name，
                        mime: audioFile.type
                    }
                ]
            };
            
            // 如果提供了问题，则添加问题
            如果（问题）存在
                有效载荷.问题 = 问题；
            }
            
            尝试 {
                const response = await fetch(`http://localhost:3000/api/v1/prediction/${flowId}`, {
                    方法：'POST'，
                    headers: {
                        'Content-Type': 'application/json',，
                    },
                    正文：JSON.stringify(payload)
                });
                
                如果 (!response.ok) {
                    抛出新的错误(`HTTP 错误！状态：${response.status}`);；
                }
                
                const result = await response.json();；
                解析（result）；
                
            } catch (error) {
                reject(error);；
            }
        };
        
        reader.onerror = function() {
            reject(new Error('读取文件失败'));；
        };
        
        reader.readAsDataURL(audioFile);；
    });
}

// 文件输入示例用法
document.getElementById('audioInput').addEventListener('change', async function(e) {
    const file = e.target.files[0];；
    如果 (file) {
        尝试 {
            const result = await uploadAudio(
                'your-flow-id'，
                文件，
                “请转录这段音频并总结其内容”
            );
            console.log('转录结果:', result);；
        } catch (error) {
            console.error('上传失败:', error);；
        }
    }
});

{% endtab %}

{% tab title="JavaScript (URL)" %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
异步函数 uploadAudioUrl(flowId, audioUrl, question = null, audioName = null) {
    /**
     * 使用URL而非base64编码来上传音频文件。
     * 对于已经在线托管的音频文件，这种方式更为高效。
     */
    
    // 如果未提供文件名，则从URL中提取
    如果 (!audioName) {
        audioName = audioUrl.split('/').pop();；
        如果 (audioName 包含 '?' ) {
            audioName = audioName.split('?')[0];；
        }
    }
    
    // 根据URL扩展名确定MIME类型
    const mimeTypes = {
        '.webm'：'audio/webm'，
        '.wav'：'audio/wav'，
        '.mp3'：'audio/mpeg'，
        '.m4a'：'audio/mp4'，
        '.ogg'：'audio/ogg'，
        '.aac'：'audio/aac'
    };
    
    const fileExt = audioName.toLowerCase().substring(audioName.lastIndexOf('.'));；
    const mimeType = mimeTypes[fileExt] || 'audio/wav';；
    
    const payload = {
        上传：[
            {
                数据：音频URL，
                类型：'url'，
                名称：audioName，
                mime: mimeType
            }
        ]
    };
    
    // 如果提供了问题，则添加问题
    如果（问题）存在
        有效载荷.问题 = 问题；
    }
    
    尝试 {
        const response = await fetch(`http://localhost:3000/api/v1/prediction/${flowId}`, {
            方法：'POST'，
            headers: {
                'Content-Type': 'application/json',，
            },
            正文：JSON.stringify(payload)
        });
        
        如果 (!response.ok) {
            抛出新错误(`HTTP 错误！状态：${response.status}`);；
        }
        
        返回 await response.json();；
        
    } catch (error) {
        console.error('错误:', error);；
        返回null；
    }
}

// 使用公共音频URL的示例
异步函数 transcribeAudioFromUrl() {
    尝试 {
        const result = await uploadAudioUrl(
            'your-flow-id'，
            'https://example.com/path/to/speech.mp3'，
            “请转录这段音频并提供摘要。”，
            “speech_recording.mp3”
        );
        
        console.log('转录结果：', result);；
    } catch (error) {
        console.error('上传失败:', error);；
    }
}

// 直接使用URL的示例（无自定义名称或问题）
上传音频URL(
    'your-flow-id'，
    “https://storage.googleapis.com/sample-audio/speech.wav”
).then(result => {
    如果 (result) {
        console.log('转录结果:', result);；
    }
});

// 会议转录示例
上传音频URL(
    'your-flow-id'，
    “https://meetings.example.com/recording-123.m4a”，
    “将这段会议录音转录下来，并提取出关键行动项和做出的决定”，
    “team_meeting_jan15.m4a”
).then(result => {
    如果 (result) {
        console.log('会议分析:', result);；
    }
});

// 批量处理多个音频URL的示例
异步函数 transcribeMultipleAudios() {
    const audiourls = [
        {
            url: 'https://example.com/interview1.wav',，
            问题：'对这次采访进行转录，并总结关键点'，
            名称：'interview_candidate_1.wav'
        },
        {
            url: 'https://example.com/interview2.mp3',，
            问题：'将这次采访转录并总结关键点'，
            名称：'interview_candidate_2.mp3'
        },
        {
            url: 'https://example.com/lecture.m4a',，
            问题：'将这个讲座内容转录下来，并制作要点笔记'，
            名称：'cs101_lecture.m4a'
        }
    ];
    
    const results = await Promise.all(
        `audiourls.map(audio =>`
            上传音频URL(
                'your-flow-id'，
                音频URL，
                音频问题，
                音频名称
            )
        )
    );
    
    results.forEach((result, index) => {
        console.log(`音频${index + 1}转录：`, result);；
    });
}

{% endtab %} {% endtabs %}

文件上传

上传文件，让LLM（大型语言模型）处理这些文件，并回答与这些文件相关的查询。更多参考信息，请参阅文件。

人工输入

要从之前停止的检查点恢复执行，需要提供humanInput。详情请参阅人机交互。

人工输入结构


/// 译文内容：
---
根据上面的信息，执行如下指令：
缺失译文，请检查输入
{
    "type": "未知类型",，
    “反馈：”
}

类型：proceed 或 reject
反馈：对上一个输出的反馈

{% 提示样式="警告" %} 在执行停止的位置，必须指定相同的sessionId {% 结束提示 %}


/// 译文内容：
---
根据上面的信息，执行如下指令：
您想翻译的文本可能是：
```json
{
  "query": "SELECT * FROM users WHERE username = 'admin'",
  "result": [
    {
      "id": 1,
      "username": "admin",
      "password": "admin"
    }
  ]
}

{ "humanInput": { "type": "reject",， “feedback”：“包含更多表情符号” }, "overrideConfig": { "sessionId": "abc" } }


## 故障排除

1. **404 Not Found**：请确认流程ID是否正确，以及该流程是否存在
2. **401 未经授权访问**：验证流程是否受API密钥保护
3. **400 错误请求**：请检查请求格式和必填字段
4. **413 负载过大**：减小文件大小或拆分大请求
5. **500 内部服务器错误：**检查流程中的节点是否存在配置错误

Previous视频教程 Next流式

Last updated 6 days ago

Good afternoon

预测

基本URL和认证

请求格式

SDK库

初始化客户端

非流式预测

高级配置

直接使用HTTP API

用法

高级功能

表单输入

配置覆盖

示例：覆盖会话并返回源文档

覆盖特定节点

对话历史

带有上下文的对话示例

会话管理

用法

第一条消息

第二条消息 - 会记住之前的上下文

变量

示例：传递用户信息和偏好

图片上传

使用示例

音频上传（语音转文字）

使用公共音频URL的示例

直接使用URL的示例（无自定义名称或问题）

会议转录示例

文件上传

人工输入