veadk-python 0.2.4__tar.gz → 0.2.6__tar.gz

{veadk_python-0.2.4 → veadk_python-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.4
+Version: 0.2.6
 Summary: Volcengine agent development kit, integrations with Volcengine cloud services.
 Author-email: Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>, Zhi Han <sliverydayday@gmail.com>, Meng Wang <mengwangwm@gmail.com>
 License:                                  Apache License

{veadk_python-0.2.4 → veadk_python-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "veadk-python"
-version = "0.2.4"
+version = "0.2.6"
 description = "Volcengine agent development kit, integrations with Volcengine cloud services."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -74,5 +74,6 @@ include-package-data = true
 
 [tool.ruff]
 exclude = [
-    "veadk/integrations/ve_faas/template/*"
+    "veadk/integrations/ve_faas/template/*",
+    "veadk/integrations/ve_faas/web_template/*"
 ]

{veadk_python-0.2.4 → veadk_python-0.2.6}/tests/test_agent.py

@@ -15,6 +15,7 @@
 from google.adk.tools import load_memory
 
 from veadk import Agent
+from veadk.consts import DEFAULT_MODEL_EXTRA_CONFIG
 from veadk.knowledgebase import KnowledgeBase
 from veadk.memory.long_term_memory import LongTermMemory
 from veadk.tools import load_knowledgebase_tool
@@ -26,11 +27,17 @@ def test_agent():
     long_term_memory = LongTermMemory(backend="local")
     tracer = OpentelemetryTracer()
 
+    extra_config = {
+        "extra_headers": {"thinking": "test"},
+        "extra_body": {"content": "test"},
+    }
+
     agent = Agent(
         model_name="test_model_name",
         model_provider="test_model_provider",
         model_api_key="test_model_api_key",
         model_api_base="test_model_api_base",
+        model_extra_config=extra_config,
         tools=[],
         sub_agents=[],
         knowledgebase=knowledgebase,
@@ -41,6 +48,12 @@ def test_agent():
 
     assert agent.model.model == f"{agent.model_provider}/{agent.model_name}"
 
+    expected_config = DEFAULT_MODEL_EXTRA_CONFIG.copy()
+    expected_config["extra_headers"] |= extra_config["extra_headers"]
+    expected_config["extra_body"] |= extra_config["extra_body"]
+
+    assert agent.model_extra_config == expected_config
+
     assert agent.knowledgebase == knowledgebase
     assert agent.knowledgebase.backend == "local"
     assert load_knowledgebase_tool.knowledgebase == agent.knowledgebase

{veadk_python-0.2.4 → veadk_python-0.2.6}/tests/test_cloud.py

@@ -115,9 +115,12 @@ async def test_cloud():
                         mock_vefaas_client = Mock()
                         mock_vefaas_in_app.return_value = mock_vefaas_client
                         mock_vefaas_client.delete.return_value = None
-
-                        cloud_app.delete_self()
-                        mock_vefaas_client.delete.assert_called_with("app-123")
+                        with patch.object(
+                            cloud_app, "_get_vefaas_application_id_by_name"
+                        ) as mock_get_id_by_name:
+                            mock_get_id_by_name.return_value = None
+                            cloud_app.delete_self()
+                            mock_vefaas_client.delete.assert_called_with("app-123")
 
                 # Verify all mocks were called as expected
                 mock_vefaas_service.deploy.assert_called_once()

{veadk_python-0.2.4 → veadk_python-0.2.6}/tests/test_runner.py

@@ -28,7 +28,9 @@ def _test_convert_messages(runner):
             role="user",
         )
     ]
-    actual_message = runner._convert_messages(message)
+    actual_message = runner._convert_messages(
+        message, session_id="test_session_id", upload_inline_data_to_tos=True
+    )
     assert actual_message == expected_message
 
     message = ["test message 1", "test message 2"]
@@ -42,7 +44,9 @@ def _test_convert_messages(runner):
             role="user",
         ),
     ]
-    actual_message = runner._convert_messages(message)
+    actual_message = runner._convert_messages(
+        message, session_id="test_session_id", upload_inline_data_to_tos=True
+    )
     assert actual_message == expected_message
 
 

veadk_python-0.2.6/tests/test_tos.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# 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.
+
+import pytest
+from unittest import mock
+
+# Check if tos module is available
+import importlib
+
+TOS_AVAILABLE = False
+try:
+    importlib.import_module("veadk.integrations.ve_tos.ve_tos")
+    TOS_AVAILABLE = True
+except ImportError:
+    pass
+
+# Skip tests that require tos module if it's not available
+require_tos = pytest.mark.skipif(not TOS_AVAILABLE, reason="tos module not available")
+
+# 使用 pytest-asyncio
+pytest_plugins = ("pytest_asyncio",)
+
+
+@pytest.fixture
+@require_tos
+def mock_client(monkeypatch):
+    import veadk.integrations.ve_tos.ve_tos as tos_mod
+
+    fake_client = mock.Mock()
+
+    monkeypatch.setenv("DATABASE_TOS_REGION", "test-region")
+    monkeypatch.setenv("VOLCENGINE_ACCESS_KEY", "test-access-key")
+    monkeypatch.setenv("VOLCENGINE_SECRET_KEY", "test-secret-key")
+    monkeypatch.setenv("DATABASE_TOS_BUCKET", "test-bucket")
+
+    monkeypatch.setattr(tos_mod.tos, "TosClientV2", lambda *a, **k: fake_client)
+
+    class FakeExceptions:
+        class TosServerError(Exception):
+            def __init__(
+                self,
+                msg: str,
+                code: int = 0,
+                host_id: str = "",
+                resource: str = "",
+                request_id: str = "",
+                header=None,
+            ):
+                super().__init__(msg)
+                self.status_code = code
+
+    monkeypatch.setattr(tos_mod.tos, "exceptions", FakeExceptions)
+    monkeypatch.setattr(
+        tos_mod.tos,
+        "StorageClassType",
+        type("S", (), {"Storage_Class_Standard": "STANDARD"}),
+    )
+    monkeypatch.setattr(
+        tos_mod.tos,
+        "ACLType",
+        type("A", (), {"ACL_Private": "private", "ACL_Public_Read": "public-read"}),
+    )
+
+    return fake_client
+
+
+@pytest.fixture
+@require_tos
+def tos_client(mock_client):
+    import veadk.integrations.ve_tos.ve_tos as tos_mod
+
+    return tos_mod.VeTOS()
+
+
+@require_tos
+def test_create_bucket_exists(tos_client, mock_client):
+    mock_client.head_bucket.return_value = None  # head_bucket 正常返回表示存在
+    result = tos_client.create_bucket()
+    assert result is True
+    mock_client.create_bucket.assert_not_called()
+
+
+@require_tos
+def test_create_bucket_not_exists(tos_client, mock_client):
+    import veadk.integrations.ve_tos.ve_tos as tos_mod
+
+    exc = tos_mod.tos.exceptions.TosServerError(msg="not found", code=404)
+    mock_client.head_bucket.side_effect = exc
+
+    result = tos_client.create_bucket()
+    assert result is True
+    mock_client.create_bucket.assert_called_once()
+
+
+@require_tos
+@pytest.mark.asyncio
+async def test_upload_bytes_success(tos_client, mock_client):
+    mock_client.head_bucket.return_value = True
+    data = b"hello world"
+
+    result = await tos_client.upload("obj-key", data)
+    assert result is None
+    mock_client.put_object.assert_called_once()
+    mock_client.close.assert_called_once()
+
+
+@require_tos
+@pytest.mark.asyncio
+async def test_upload_file_success(tmp_path, tos_client, mock_client):
+    mock_client.head_bucket.return_value = True
+    file_path = tmp_path / "file.txt"
+    file_path.write_text("hello file")
+
+    result = await tos_client.upload("obj-key", str(file_path))
+    assert result is None
+    mock_client.put_object_from_file.assert_called_once()
+    mock_client.close.assert_called_once()
+
+
+@require_tos
+def test_download_success(tmp_path, tos_client, mock_client):
+    save_path = tmp_path / "out.txt"
+    mock_client.get_object.return_value = [b"abc", b"def"]
+
+    result = tos_client.download("obj-key", str(save_path))
+    assert result is True
+    assert save_path.read_bytes() == b"abcdef"
+
+
+@require_tos
+def test_download_fail(tos_client, mock_client):
+    mock_client.get_object.side_effect = Exception("boom")
+    result = tos_client.download("obj-key", "somewhere.txt")
+    assert result is False
+
+
+@require_tos
+@pytest.mark.skipif(TOS_AVAILABLE, reason="tos module is available")
+def test_tos_import_error():
+    """Test VeTOS behavior when tos module is not installed"""
+    # Remove tos from sys.modules to simulate it's not installed
+    import sys
+
+    original_tos = sys.modules.get("tos")
+    if "tos" in sys.modules:
+        del sys.modules["tos"]
+
+    try:
+        # Try to import ve_tos module, which should raise ImportError
+        with pytest.raises(ImportError) as exc_info:
+            pass
+
+        # Check that the error message contains installation instructions
+        assert "pip install tos" in str(exc_info.value)
+    finally:
+        # Restore original state
+        if original_tos is not None:
+            sys.modules["tos"] = original_tos

{veadk_python-0.2.4 → veadk_python-0.2.6}/veadk/agent.py

@@ -28,9 +28,10 @@ from typing_extensions import Any
 
 from veadk.config import getenv
 from veadk.consts import (
-    DEFALUT_MODEL_AGENT_PROVIDER,
     DEFAULT_MODEL_AGENT_API_BASE,
     DEFAULT_MODEL_AGENT_NAME,
+    DEFAULT_MODEL_AGENT_PROVIDER,
+    DEFAULT_MODEL_EXTRA_CONFIG,
 )
 from veadk.evaluation import EvalSetRecorder
 from veadk.knowledgebase import KnowledgeBase
@@ -64,7 +65,7 @@ class Agent(LlmAgent):
     model_name: str = getenv("MODEL_AGENT_NAME", DEFAULT_MODEL_AGENT_NAME)
     """The name of the model for agent running."""
 
-    model_provider: str = getenv("MODEL_AGENT_PROVIDER", DEFALUT_MODEL_AGENT_PROVIDER)
+    model_provider: str = getenv("MODEL_AGENT_PROVIDER", DEFAULT_MODEL_AGENT_PROVIDER)
     """The provider of the model for agent running."""
 
     model_api_base: str = getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE)
@@ -73,6 +74,9 @@ class Agent(LlmAgent):
     model_api_key: str = Field(default_factory=lambda: getenv("MODEL_AGENT_API_KEY"))
     """The api key of the model for agent running."""
 
+    model_extra_config: dict = Field(default_factory=dict)
+    """The extra config to include in the model requests."""
+
     tools: list[ToolUnion] = []
     """The tools provided to agent."""
 
@@ -96,11 +100,39 @@ class Agent(LlmAgent):
 
     def model_post_init(self, __context: Any) -> None:
         super().model_post_init(None)  # for sub_agents init
-        self.model = LiteLlm(
-            model=f"{self.model_provider}/{self.model_name}",
-            api_key=self.model_api_key,
-            api_base=self.model_api_base,
-        )
+
+        # combine user model config with VeADK defaults
+        headers = DEFAULT_MODEL_EXTRA_CONFIG["extra_headers"].copy()
+        body = DEFAULT_MODEL_EXTRA_CONFIG["extra_body"].copy()
+
+        if self.model_extra_config:
+            user_headers = self.model_extra_config.get("extra_headers", {})
+            user_body = self.model_extra_config.get("extra_body", {})
+
+            headers |= user_headers
+            body |= user_body
+
+        self.model_extra_config |= {
+            "extra_headers": headers,
+            "extra_body": body,
+        }
+
+        logger.info(f"Model extra config: {self.model_extra_config}")
+
+        if not self.model:
+            self.model = LiteLlm(
+                model=f"{self.model_provider}/{self.model_name}",
+                api_key=self.model_api_key,
+                api_base=self.model_api_base,
+                **self.model_extra_config,
+            )
+            logger.debug(
+                f"LiteLLM client created with config: {self.model_extra_config}"
+            )
+        else:
+            logger.warning(
+                "You are trying to use your own LiteLLM client, some default request headers may be missing."
+            )
 
         if self.knowledgebase:
             from veadk.tools import load_knowledgebase_tool
@@ -117,7 +149,7 @@ class Agent(LlmAgent):
 
         logger.info(f"{self.__class__.__name__} `{self.name}` init done.")
         logger.debug(
-            f"Agent: {self.model_dump(include={'name', 'model_name', 'model_api_base', 'tools', 'serve_url'})}"
+            f"Agent: {self.model_dump(include={'name', 'model_name', 'model_api_base', 'tools'})}"
         )
 
     async def _run(

{veadk_python-0.2.4 → veadk_python-0.2.6}/veadk/cli/cli_deploy.py

@@ -14,6 +14,7 @@
 
 
 import click
+from veadk.version import VERSION
 
 TEMP_PATH = "/tmp"
 
@@ -29,7 +30,9 @@ TEMP_PATH = "/tmp"
     default=None,
     help="Volcengine secret key",
 )
-@click.option("--vefaas-app-name", help="Expected Volcengine FaaS application name")
+@click.option(
+    "--vefaas-app-name", required=True, help="Expected Volcengine FaaS application name"
+)
 @click.option(
     "--veapig-instance-name", default="", help="Expected Volcengine APIG instance name"
 )
@@ -92,6 +95,7 @@ def deploy(
         "veapig_service_name": veapig_service_name,
         "veapig_upstream_name": veapig_upstream_name,
         "use_adk_web": use_adk_web,
+        "veadk_version": VERSION,
     }
 
     cookiecutter(

{veadk_python-0.2.4 → veadk_python-0.2.6}/veadk/cli/cli_init.py

@@ -16,6 +16,8 @@ import warnings
 from typing import Any
 
 import click
+from veadk.version import VERSION
+
 
 warnings.filterwarnings(
     "ignore", category=UserWarning, module="pydantic._internal._fields"
@@ -58,12 +60,21 @@ def _render_prompts() -> dict[str, Any]:
         "veapig_service_name": veapig_service_name,
         "veapig_upstream_name": veapig_upstream_name,
         "use_adk_web": deploy_mode == "2",
+        "veadk_version": VERSION,
     }
 
 
 @click.command()
-def init() -> None:
-    """Init a veadk project that can be deployed to Volcengine VeFaaS."""
+@click.option(
+    "--vefaas-template-type", default="template", help="Expected template type"
+)
+def init(
+    vefaas_template_type: str,
+) -> None:
+    """Init a veadk project that can be deployed to Volcengine VeFaaS.
+
+    `template` is A2A/MCP/Web server template, `web_template` is for web applications (i.e., a simple blog).
+    """
     import shutil
     from pathlib import Path
 
@@ -71,9 +82,14 @@ def init() -> None:
 
     import veadk.integrations.ve_faas as vefaas
 
-    click.echo(
-        "Welcome use VeADK to create your project. We will generate a `weather-reporter` application for you."
-    )
+    if vefaas_template_type == "web_template":
+        click.echo(
+            "Welcome use VeADK to create your project. We will generate a `simple-blog` web application for you."
+        )
+    else:
+        click.echo(
+            "Welcome use VeADK to create your project. We will generate a `weather-reporter` application for you."
+        )
 
     cwd = Path.cwd()
     local_dir_name = click.prompt("Local directory name", default="veadk-cloud-proj")
@@ -89,7 +105,10 @@ def init() -> None:
     settings = _render_prompts()
     settings["local_dir_name"] = local_dir_name
 
-    template_dir_path = Path(vefaas.__file__).parent / "template"
+    if not vefaas_template_type:
+        vefaas_template_type = "template"
+
+    template_dir_path = Path(vefaas.__file__).parent / vefaas_template_type
 
     cookiecutter(
         template=str(template_dir_path),

{veadk_python-0.2.4 → veadk_python-0.2.6}/veadk/cloud/cloud_app.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import json
+import time
 from typing import Any
 from uuid import uuid4
 
@@ -60,9 +61,11 @@ class CloudApp:
         if not vefaas_endpoint:
             self.vefaas_endpoint = self._get_vefaas_endpoint()
 
-        if not self.vefaas_endpoint.startswith(
-            "http"
-        ) and not self.vefaas_endpoint.startswith("https"):
+        if (
+            self.vefaas_endpoint
+            and not self.vefaas_endpoint.startswith("http")
+            and not self.vefaas_endpoint.startswith("https")
+        ):
             raise ValueError(
                 f"Invalid endpoint: {vefaas_endpoint}. The endpoint must start with `http` or `https`."
             )
@@ -92,12 +95,13 @@ class CloudApp:
             raise ValueError(
                 f"VeFaaS CloudAPP with application_id `{self.vefaas_application_id}` or application_name `{self.vefaas_application_name}` not found."
             )
-        cloud_resource = json.loads(app["CloudResource"])
 
         try:
+            cloud_resource = json.loads(app["CloudResource"])
             vefaas_endpoint = cloud_resource["framework"]["url"]["system_url"]
         except Exception as e:
-            raise ValueError(f"VeFaaS cloudAPP could not get endpoint. Error: {e}")
+            logger.warning(f"VeFaaS cloudAPP could not get endpoint. Error: {e}")
+            vefaas_endpoint = ""
         return vefaas_endpoint
 
     def _get_vefaas_application_id_by_name(self) -> str:
@@ -167,7 +171,18 @@ class CloudApp:
 
             vefaas_client = VeFaaS(access_key=volcengine_ak, secret_key=volcengine_sk)
             vefaas_client.delete(self.vefaas_application_id)
-            print(f"Cloud app {self.vefaas_application_id} is deleting...")
+            print(
+                f"Cloud app {self.vefaas_application_id} delete request has been sent to VeFaaS"
+            )
+            while True:
+                try:
+                    id = self._get_vefaas_application_id_by_name()
+                    if not id:
+                        break
+                    time.sleep(3)
+                except Exception as _:
+                    break
+            print("Delete application done.")
 
     async def message_send(
         self, message: str, session_id: str, user_id: str, timeout: float = 600.0

veadk_python-0.2.6/veadk/consts.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# 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.
+
+import time
+
+from veadk.config import getenv
+from veadk.version import VERSION
+
+DEFAULT_MODEL_AGENT_NAME = "doubao-seed-1-6-250615"
+DEFAULT_MODEL_AGENT_PROVIDER = "openai"
+DEFAULT_MODEL_AGENT_API_BASE = "https://ark.cn-beijing.volces.com/api/v3/"
+DEFAULT_MODEL_EXTRA_CONFIG = {
+    "extra_headers": {
+        "x-is-encrypted": getenv("MODEL_AGENT_ENCRYPTED", "true"),
+        "veadk-source": "veadk",
+        "veadk-version": VERSION,
+    },
+    "extra_body": {
+        "caching": {
+            "type": getenv("MODEL_AGENT_CACHING", "enabled"),
+        },
+        "expire_at": int(time.time()) + 3600,  # expire after 1 hour
+    },
+}
+
+DEFAULT_APMPLUS_OTEL_EXPORTER_ENDPOINT = "http://apmplus-cn-beijing.volces.com:4317"
+DEFAULT_APMPLUS_OTEL_EXPORTER_SERVICE_NAME = "veadk_tracing"
+
+DEFAULT_COZELOOP_OTEL_EXPORTER_ENDPOINT = (
+    "https://api.coze.cn/v1/loop/opentelemetry/v1/traces"
+)
+
+DEFAULT_TLS_OTEL_EXPORTER_ENDPOINT = "https://tls-cn-beijing.volces.com:4318/v1/traces"
+DEFAULT_TLS_OTEL_EXPORTER_REGION = "cn-beijing"
+
+DEFAULT_CR_INSTANCE_NAME = "veadk-user-instance"
+DEFAULT_CR_NAMESPACE_NAME = "veadk-user-namespace"
+DEFAULT_CR_REPO_NAME = "veadk-user-repo"

{veadk_python-0.2.4 → veadk_python-0.2.6}/veadk/database/database_adapter.py

@@ -54,6 +54,33 @@ class KVDatabaseAdapter:
             logger.error(f"Failed to search from Redis: index={index} error={e}")
             raise e
 
+    def delete_doc(self, index: str, id: str) -> bool:
+        logger.debug(f"Deleting document from Redis database: index={index} id={id}")
+        try:
+            # For Redis, we need to handle deletion differently since RedisDatabase.delete_doc
+            # takes a key and a single id
+            result = self.client.delete_doc(key=index, id=id)
+            return result
+        except Exception as e:
+            logger.error(
+                f"Failed to delete document from Redis database: index={index} id={id} error={e}"
+            )
+            return False
+
+    def list_docs(self, index: str, offset: int = 0, limit: int = 100) -> list[dict]:
+        logger.debug(f"Listing documents from Redis database: index={index}")
+        try:
+            # Get all documents from Redis
+            docs = self.client.list_docs(key=index)
+
+            # Apply offset and limit for pagination
+            return docs[offset : offset + limit]
+        except Exception as e:
+            logger.error(
+                f"Failed to list documents from Redis database: index={index} error={e}"
+            )
+            return []
+
 
 class RelationalDatabaseAdapter:
     def __init__(self, client):
@@ -108,6 +135,28 @@ class RelationalDatabaseAdapter:
 
         return [item["data"] for item in results]
 
+    def delete_doc(self, index: str, id: str) -> bool:
+        logger.debug(f"Deleting document from SQL database: table_name={index} id={id}")
+        try:
+            # Convert single id to list for the client method
+            result = self.client.delete_doc(table=index, ids=[int(id)])
+            return result
+        except Exception as e:
+            logger.error(
+                f"Failed to delete document from SQL database: table_name={index} id={id} error={e}"
+            )
+            return False
+
+    def list_docs(self, index: str, offset: int = 0, limit: int = 100) -> list[dict]:
+        logger.debug(f"Listing documents from SQL database: table_name={index}")
+        try:
+            return self.client.list_docs(table=index, offset=offset, limit=limit)
+        except Exception as e:
+            logger.error(
+                f"Failed to list documents from SQL database: table_name={index} error={e}"
+            )
+            return []
+
 
 class VectorDatabaseAdapter:
     def __init__(self, client):
@@ -152,6 +201,23 @@ class VectorDatabaseAdapter:
             top_k=top_k,
         )
 
+    def delete_doc(self, index: str, id: str) -> bool:
+        self._validate_index(index)
+        logger.debug(f"Deleting documents from vector database: index={index} id={id}")
+        try:
+            self.client.delete_by_id(collection_name=index, id=id)
+            return True
+        except Exception as e:
+            logger.error(
+                f"Failed to delete document from vector database: index={index} id={id} error={e}"
+            )
+            return False
+
+    def list_docs(self, index: str, offset: int = 0, limit: int = 1000) -> list[dict]:
+        self._validate_index(index)
+        logger.debug(f"Listing documents from vector database: index={index}")
+        return self.client.list_docs(collection_name=index, offset=offset, limit=limit)
+
 
 class VikingDatabaseAdapter:
     def __init__(self, client):
@@ -212,6 +278,16 @@ class VikingDatabaseAdapter:
 
         return self.client.query(query, collection_name=index, top_k=top_k)
 
+    def delete_doc(self, index: str, id: str) -> bool:
+        self._validate_index(index)
+        logger.debug(f"Deleting documents from vector database: index={index} id={id}")
+        return self.client.delete_by_id(collection_name=index, id=id)
+
+    def list_docs(self, index: str, offset: int, limit: int) -> list[dict]:
+        self._validate_index(index)
+        logger.debug(f"Listing documents from vector database: index={index}")
+        return self.client.list_docs(collection_name=index, offset=offset, limit=limit)
+
 
 class VikingMemoryDatabaseAdapter:
     def __init__(self, client):
@@ -248,6 +324,12 @@ class VikingMemoryDatabaseAdapter:
         result = self.client.query(query, collection_name=index, top_k=top_k, **kwargs)
         return result
 
+    def delete_docs(self, index: str, ids: list[int]):
+        raise NotImplementedError("VikingMemoryDatabase does not support delete_docs")
+
+    def list_docs(self, index: str):
+        raise NotImplementedError("VikingMemoryDatabase does not support list_docs")
+
 
 class LocalDatabaseAdapter:
     def __init__(self, client):
@@ -261,6 +343,12 @@ class LocalDatabaseAdapter:
     def query(self, query: str, **kwargs):
         return self.client.query(query, **kwargs)
 
+    def delete_doc(self, index: str, id: str) -> bool:
+        return self.client.delete_doc(id)
+
+    def list_docs(self, index: str, offset: int = 0, limit: int = 100) -> list[dict]:
+        return self.client.list_docs(offset=offset, limit=limit)
+
 
 MAPPING = {
     "RedisDatabase": KVDatabaseAdapter,