Feat: Agent api

api/apps/canvas_app.py

@@ -24,10 +24,9 @@
 from api.db.services.canvas_service import CanvasTemplateService, UserCanvasService, API4ConversationService
 from api.db.services.document_service import DocumentService
 from api.db.services.file_service import FileService
 from api.db.services.knowledgebase_service import KnowledgebaseService
 from api.db.services.pipeline_operation_log_service import PipelineOperationLogService
 from api.db.services.task_service import queue_dataflow, CANVAS_DEBUG_DOC_ID, TaskService
-from api.db.services.user_service import TenantService
 from api.db.services.user_canvas_version import UserCanvasVersionService
 from common.constants import RetCode
 from common.misc_utils import get_uuid, thread_pool_exec
@@ -39,7 +38,7 @@
     get_request_json,
 )
 from agent.canvas import Canvas
 from agent.dsl_migration import normalize_chunker_dsl
 from peewee import MySQLDatabase, PostgresqlDatabase
 from api.db.db_models import APIToken, Task
 
@@ -115,56 +114,6 @@
         return get_data_error_result(message="canvas saved, but replica sync failed.")
     return get_json_result(data=req)
 
-
-@manager.route('/get/<canvas_id>', methods=['GET'])  # noqa: F821
-@login_required
-def get(canvas_id):
-    if not UserCanvasService.accessible(canvas_id, current_user.id):
-        return get_data_error_result(message="canvas not found.")
-    e, c = UserCanvasService.get_by_canvas_id(canvas_id)
-    if not e:
-        return get_data_error_result(message="canvas not found.")
-    try:
-        # DELETE
-        CanvasReplicaService.bootstrap(
-            canvas_id=canvas_id,
-            tenant_id=str(current_user.id),
-            runtime_user_id=str(current_user.id),
-            dsl=c.get("dsl"),
-            canvas_category=c.get("canvas_category", CanvasCategory.Agent),
-            title=c.get("title", ""),
-        )
-    except ValueError as e:
-        return get_data_error_result(message=str(e))
-
-    # Get the last publication time (latest released version's update_time)
-    last_publish_time = None
-    versions = UserCanvasVersionService.list_by_canvas_id(canvas_id)
-    if versions:
-        released_versions = [v for v in versions if v.release]
-        if released_versions:
-            # Sort by update_time descending and get the latest
-            released_versions.sort(key=lambda x: x.update_time, reverse=True)
-            last_publish_time = released_versions[0].update_time
-
-    # Add last_publish_time to response data
-    if isinstance(c, dict):
-        c["dsl"] = normalize_chunker_dsl(c.get("dsl", {}))
-        c["last_publish_time"] = last_publish_time
-    else:
-        # If c is a model object, convert to dict first
-        c = c.to_dict()
-        c["dsl"] = normalize_chunker_dsl(c.get("dsl", {}))
-        c["last_publish_time"] = last_publish_time
-
-    # For pipeline type, get associated datasets
-    if c.get("canvas_category") == CanvasCategory.DataFlow:
-        datasets = list(KnowledgebaseService.query(pipeline_id=canvas_id))
-        c["datasets"] = [{"id": d.id, "name": d.name, "avatar": d.avatar} for d in datasets]
-
-    return get_json_result(data=c)
-
-
 @manager.route('/getsse/<canvas_id>', methods=['GET'])  # type: ignore # noqa: F821
 def getsse(canvas_id):
     token = request.headers.get('Authorization').split()
@@ -575,34 +524,6 @@
         return get_json_result(data=f"Error getting history file: {e}")
 
 
-@manager.route('/list', methods=['GET'])  # noqa: F821
-@login_required
-def list_canvas():
-    keywords = request.args.get("keywords", "")
-    page_number = int(request.args.get("page", 0))
-    items_per_page = int(request.args.get("page_size", 0))
-    orderby = request.args.get("orderby", "create_time")
-    canvas_category = request.args.get("canvas_category")
-    if request.args.get("desc", "true").lower() == "false":
-        desc = False
-    else:
-        desc = True
-    owner_ids = [id for id in request.args.get("owner_ids", "").strip().split(",") if id]
-    if not owner_ids:
-        tenants = TenantService.get_joined_tenants_by_user_id(current_user.id)
-        tenants = [m["tenant_id"] for m in tenants]
-        tenants.append(current_user.id)
-        canvas, total = UserCanvasService.get_by_tenant_ids(
-            tenants, current_user.id, page_number,
-            items_per_page, orderby, desc, keywords, canvas_category)
-    else:
-        tenants = owner_ids
-        canvas, total = UserCanvasService.get_by_tenant_ids(
-            tenants, current_user.id, 0,
-            0, orderby, desc, keywords, canvas_category)
-    return get_json_result(data={"canvas": canvas, "total": total})
-
-
 @manager.route('/setting', methods=['POST'])  # noqa: F821
 @validate_request("id", "title", "permission")
 @login_required

api/apps/restful_apis/agent_api.py

@@ -0,0 +1,110 @@
+#
+#  Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from quart import request
+
+from agent.dsl_migration import normalize_chunker_dsl
+from api.apps import current_user, login_required
+from api.apps.services.canvas_replica_service import CanvasReplicaService
+from api.db import CanvasCategory
+from api.db.services.canvas_service import UserCanvasService
+from api.db.services.knowledgebase_service import KnowledgebaseService
+from api.db.services.user_service import TenantService
+from api.db.services.user_canvas_version import UserCanvasVersionService
+from api.utils.api_utils import add_tenant_id_to_kwargs, get_data_error_result, get_json_result
+
+
+@manager.route("/agents", methods=["GET"])  # noqa: F821
+@login_required
+@add_tenant_id_to_kwargs
+def list_agents(tenant_id):
+    keywords = request.args.get("keywords", "")
+    canvas_category = request.args.get("canvas_category")
+    owner_ids = [item for item in request.args.get("owner_ids", "").strip().split(",") if item]
+
+    page_number = int(request.args.get("page", 0))
+    items_per_page = int(request.args.get("page_size", 0))
+    order_by = request.args.get("orderby", "create_time")
+    desc = str(request.args.get("desc", "true")).lower() != "false"
+
+    if not owner_ids:
+        tenants = TenantService.get_joined_tenants_by_user_id(current_user.id)
+        tenants = [member["tenant_id"] for member in tenants]
+        tenants.append(current_user.id)
+        canvas, total = UserCanvasService.get_by_tenant_ids(
+            tenants,
+            current_user.id,
+            page_number,
+            items_per_page,
+            order_by,
+            desc,
+            keywords,
+            canvas_category,
+        )
+    else:
+        canvas, total = UserCanvasService.get_by_tenant_ids(
+            owner_ids,
+            current_user.id,
+            0,
+            0,
+            order_by,
+            desc,
+            keywords,
+            canvas_category,
+        )
+
+    return get_json_result(data={"canvas": canvas, "total": total})
+
+
+@manager.route("/agents/<agent_id>", methods=["GET"])  # noqa: F821
+@login_required
+@add_tenant_id_to_kwargs
+def get_agent(agent_id, tenant_id):
+    if not UserCanvasService.accessible(agent_id, current_user.id):
+        return get_data_error_result(message="canvas not found.")
+
+    exists, canvas = UserCanvasService.get_by_canvas_id(agent_id)
+    if not exists:
+        return get_data_error_result(message="canvas not found.")
+
+    try:
+        CanvasReplicaService.bootstrap(
+            canvas_id=agent_id,
+            tenant_id=str(tenant_id),
+            runtime_user_id=str(current_user.id),
+            dsl=canvas.get("dsl"),
+            canvas_category=canvas.get("canvas_category", CanvasCategory.Agent),
+            title=canvas.get("title", ""),
+        )
+    except ValueError as exc:
+        return get_data_error_result(message=str(exc))
+
+    last_publish_time = None
+    versions = UserCanvasVersionService.list_by_canvas_id(agent_id)
+    if versions:
+        released_versions = [version for version in versions if version.release]
+        if released_versions:
+            released_versions.sort(key=lambda version: version.update_time, reverse=True)
+            last_publish_time = released_versions[0].update_time
+
+    canvas["dsl"] = normalize_chunker_dsl(canvas.get("dsl", {}))
+    canvas["last_publish_time"] = last_publish_time
+
+    if canvas.get("canvas_category") == CanvasCategory.DataFlow:
+        datasets = list(KnowledgebaseService.query(pipeline_id=agent_id))
+        canvas["datasets"] = [{"id": item.id, "name": item.name, "avatar": item.avatar} for item in datasets]
+
+    return get_json_result(data=canvas)

api/apps/sdk/agents.py

@@ -35,8 +35,8 @@
 from api.db.services.user_canvas_version import UserCanvasVersionService
 from common.constants import RetCode
 from common.misc_utils import get_uuid
 from api.utils.api_utils import get_data_error_result, get_error_data_result, get_json_result, get_request_json, token_required
 from api.utils.api_utils import get_result
 from quart import request, Response
 from rag.utils.redis_conn import REDIS_CONN
 
@@ -47,27 +47,6 @@
         return user_id
     return str(getattr(user, "nickname", "") or user_id)
 
-
-@manager.route('/agents', methods=['GET'])  # noqa: F821
-@token_required
-def list_agents(tenant_id):
-    id = request.args.get("id")
-    title = request.args.get("title")
-    if id or title:
-        canvas = UserCanvasService.query(id=id, title=title, user_id=tenant_id)
-        if not canvas:
-            return get_error_data_result("The agent doesn't exist.")
-    page_number = int(request.args.get("page", 1))
-    items_per_page = int(request.args.get("page_size", 30))
-    order_by = request.args.get("orderby", "update_time")
-    if str(request.args.get("desc","false")).lower() == "false":
-        desc = False
-    else:
-        desc = True
-    canvas = UserCanvasService.get_list(tenant_id, page_number, items_per_page, order_by, desc, id, title)
-    return get_result(data=canvas)
-
-
 @manager.route("/agents", methods=["POST"])  # noqa: F821
 @token_required
 async def create_agent(tenant_id: str):

docs/references/python_api_reference.md

@@ -1702,7 +1702,7 @@ from ragflow_sdk import RAGFlow, Agent
 
 rag_object = RAGFlow(api_key="<YOUR_API_KEY>", base_url="http://<YOUR_BASE_URL>:9380")
 agent_id = "AGENT_ID"
-agent = rag_object.list_agents(id = agent_id)[0]
+agent = rag_object.get_agent(agent_id)
 session = agent.create_session()
 # Or create in release mode:
 # session = agent.create_session(release=True)
@@ -1784,7 +1784,7 @@ from ragflow_sdk import RAGFlow, Agent
 
 rag_object = RAGFlow(api_key="<YOUR_API_KEY>", base_url="http://<YOUR_BASE_URL>:9380")
 AGENT_id = "AGENT_ID"
-agent = rag_object.list_agents(id = AGENT_id)[0]
+agent = rag_object.get_agent(AGENT_id)
 session = agent.create_session()    
 
 print("\n===== Miss R ====\n")
@@ -1853,7 +1853,7 @@ from ragflow_sdk import RAGFlow
 
 rag_object = RAGFlow(api_key="<YOUR_API_KEY>", base_url="http://<YOUR_BASE_URL>:9380")
 AGENT_id = "AGENT_ID"
-agent = rag_object.list_agents(id = AGENT_id)[0]
+agent = rag_object.get_agent(AGENT_id)
 sessons = agent.list_sessions()
 for session in sessions:
     print(session)
@@ -1892,7 +1892,7 @@ from ragflow_sdk import RAGFlow
 
 rag_object = RAGFlow(api_key="<YOUR_API_KEY>", base_url="http://<YOUR_BASE_URL>:9380")
 AGENT_id = "AGENT_ID"
-agent = rag_object.list_agents(id = AGENT_id)[0]
+agent = rag_object.get_agent(AGENT_id)
 agent.delete_sessions(ids=["id_1","id_2"])
 agent.delete_sessions(delete_all=True)
 ```
@@ -1909,7 +1909,7 @@ agent.delete_sessions(delete_all=True)
 RAGFlow.list_agents(
     page: int = 1, 
     page_size: int = 30, 
-    orderby: str = "create_time", 
+    orderby: str = "update_time", 
     desc: bool = True,
     id: str = None,
     title: str = None
@@ -1932,8 +1932,8 @@ The number of agents on each page. Defaults to `30`.
 
 The attribute by which the results are sorted. Available options:
 
-- `"create_time"` (default)
-- `"update_time"`
+- `"create_time"`
+- `"update_time"` (default)
 
 ##### desc: `bool`
 
@@ -1943,7 +1943,7 @@ Indicates whether the retrieved agents should be sorted in descending order. Def
 
 The ID of the agent to retrieve. Defaults to `None`.
 
-##### name: `string`  
+##### title: `string`  
 
 The name of the agent to retrieve. Defaults to `None`.
 
@@ -1963,6 +1963,37 @@ for agent in rag_object.list_agents():
 
 ---
 
+### Get agent
+
+```python
+RAGFlow.get_agent(agent_id: str) -> Agent
+```
+
+Gets an agent by ID.
+
+#### Parameters
+
+##### agent_id: `string`
+
+The ID of the agent to retrieve.
+
+#### Returns
+
+- Success: An `Agent` object.
+- Failure: `Exception`.
+
+#### Examples
+
+```python
+from ragflow_sdk import RAGFlow
+
+rag_object = RAGFlow(api_key="<YOUR_API_KEY>", base_url="http://<YOUR_BASE_URL>:9380")
+agent = rag_object.get_agent("AGENT_ID")
+print(agent)
+```
+
+---
+
 ### Create agent
 
 ```python

sdk/python/ragflow_sdk/ragflow.py

@@ -231,25 +231,39 @@ def retrieve(
         raise Exception(res.get("message"))
 
     def list_agents(self, page: int = 1, page_size: int = 30, orderby: str = "update_time", desc: bool = True, id: str | None = None, title: str | None = None) -> list[Agent]:
+        if id is not None:
+            agent = self.get_agent(id)
+            if title is not None and agent.title != title:
+                return []
+            return [agent]
+
         res = self.get(
             "/agents",
             {
                 "page": page,
                 "page_size": page_size,
                 "orderby": orderby,
                 "desc": desc,
-                "id": id,
-                "title": title,
             },
         )
         res = res.json()
         result_list = []
         if res.get("code") == 0:
-            for data in res["data"]:
+            data_list = res.get("data", {}).get("canvas", [])
+            for data in data_list:
+                if title is not None and data.get("title") != title:
+                    continue
                 result_list.append(Agent(self, data))
             return result_list
         raise Exception(res["message"])
 
+    def get_agent(self, agent_id: str) -> Agent:
+        res = self.get(f"/agents/{agent_id}")
+        res = res.json()
+        if res.get("code") == 0:
+            return Agent(self, res["data"])
+        raise Exception(res["message"])
+
     def create_agent(self, title: str, dsl: dict, description: str | None = None) -> None:
         req = {"title": title, "dsl": dsl}