veadk-python 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

veadk/evaluation/base_evaluator.py

@@ -217,15 +217,16 @@ class BaseEvaluator:
 
         for eval_case in eval_cases:
             eval_case_data = EvalCaseData(invocations=[])
-            self.agent_information_list.append(
-                {
-                    "app_name": eval_case.session_input.app_name,
-                    "user_id": eval_case.session_input.user_id,
-                    "session_id": str(
-                        uuid.uuid4()
-                    ),  # random session id for evaluation,
-                }
-            )
+            if eval_case.session_input:
+                self.agent_information_list.append(
+                    {
+                        "app_name": eval_case.session_input.app_name,
+                        "user_id": eval_case.session_input.user_id,
+                        "session_id": str(
+                            uuid.uuid4()
+                        ),  # random session id for evaluation,
+                    }
+                )
 
             for invocation in eval_case.conversation:
                 _input: str = ""

veadk/evaluation/utils/prometheus.py

@@ -23,19 +23,16 @@ from veadk.evaluation.types import EvalResultCaseData, EvalResultMetadata
 
 class PrometheusPushgatewayConfig:
     url: str = Field(
-        ...,
         default_factory=lambda: getenv(
             "OBSERVABILITY_PROMETHEUS_PUSHGATEWAY_URL",
         ),
     )
     username: str = Field(
-        ...,
         default_factory=lambda: getenv(
             "OBSERVABILITY_PROMETHEUS_USERNAME",
         ),
     )
     password: str = Field(
-        ...,
         default_factory=lambda: getenv(
             "OBSERVABILITY_PROMETHEUS_PASSWORD",
         ),
@@ -88,7 +85,7 @@ def post_pushgateway(
     password: str,
     job_name: str,
     registry: CollectorRegistry,
-    grouping_key: dict[str, str] = None,
+    grouping_key: dict[str, str] | None = None,
 ):
     def auth_handler(url, method, timeout, headers, data):
         return basic_auth_handler(

veadk/integrations/ve_faas/template/cookiecutter.json

@@ -0,0 +1,11 @@
+{
+  "local_dir_name": "veadk_vefaas_proj",
+  "app_name": "weather-report",
+  "agent_module_name": "weather_agent",
+  "short_term_memory_backend": "local",
+  "vefaas_application_name": "weather-reporter",
+  "veapig_instance_name": "",
+  "veapig_service_name": "",
+  "veapig_upstream_name": "",
+  "use_adk_web": false
+}

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/config.yaml.example

@@ -0,0 +1,6 @@
+model:
+  agent:
+    provider: openai
+    name: doubao-1-5-pro-256k-250115
+    api_base: https://ark.cn-beijing.volces.com/api/v3/
+    api_key: 

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/deploy.py

@@ -0,0 +1,103 @@
+# 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 asyncio
+from pathlib import Path
+
+from a2a.types import TextPart
+from fastmcp.client import Client
+
+from veadk.cloud.cloud_agent_engine import CloudAgentEngine
+from veadk.cloud.cloud_app import CloudApp, get_message_id
+
+SESSION_ID = "cloud_app_test_session"
+USER_ID = "cloud_app_test_user"
+
+
+async def _send_msg_with_a2a(cloud_app: CloudApp, message: str) -> None:
+    print("===== A2A example =====")
+
+    response_message = await cloud_app.message_send(message, SESSION_ID, USER_ID)
+
+    if not response_message or not response_message.parts:
+        print(
+            "No response from VeFaaS application. Something wrong with cloud application."
+        )
+        return
+
+    print(f"Message ID: {get_message_id(response_message)}")
+
+    if isinstance(response_message.parts[0].root, TextPart):
+        print(
+            f"Response from {cloud_app.vefaas_endpoint}: {response_message.parts[0].root.text}"
+        )
+    else:
+        print(
+            f"Response from {cloud_app.vefaas_endpoint}: {response_message.parts[0].root}"
+        )
+
+
+async def _send_msg_with_mcp(cloud_app: CloudApp, message: str) -> None:
+    print("===== MCP example =====")
+
+    endpoint = cloud_app._get_vefaas_endpoint()
+    print(f"MCP server endpoint: {endpoint}/mcp")
+
+    # Connect to MCP server
+    client = Client(f"{endpoint}/mcp")
+
+    async with client:
+        # List available tools
+        tools = await client.list_tools()
+        print(f"Available tools: {tools}")
+
+        # Call run_agent tool, pass user input and session information
+        res = await client.call_tool(
+            "run_agent",
+            {
+                "user_input": message,
+                "session_id": SESSION_ID,
+                "user_id": USER_ID,
+            },
+        )
+        print(f"Response from {cloud_app.vefaas_endpoint}: {res}")
+
+
+async def main():
+    engine = CloudAgentEngine()
+
+    cloud_app = engine.deploy(
+        path=str(Path(__file__).parent / "src"),
+        application_name="{{cookiecutter.vefaas_application_name}}",
+        gateway_name="{{cookiecutter.veapig_instance_name}}",
+        gateway_service_name="{{cookiecutter.veapig_service_name}}",
+        gateway_upstream_name="{{cookiecutter.veapig_upstream_name}}",
+        use_adk_web={{cookiecutter.use_adk_web}},
+        local_test=False,  # Set to True for local testing before deploy to VeFaaS
+    )
+    print(f"VeFaaS application ID: {cloud_app.vefaas_application_id}")
+
+    if {{cookiecutter.use_adk_web}}:
+        print(f"Web is running at: {cloud_app.vefaas_endpoint}")
+    else:
+        # Test with deployed cloud application
+        message = "How is the weather like in Beijing?"
+        print(f"Test message: {message}")
+
+        await _send_msg_with_a2a(cloud_app=cloud_app, message=message)
+        await _send_msg_with_mcp(cloud_app=cloud_app, message=message)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

veadk/{cli/services/vefaas/template → integrations/ve_faas/template/{{cookiecutter.local_dir_name}}}/src/__init__.py

@@ -11,4 +11,3 @@
 # 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 . import agent  # noqa F401

veadk/{cli/services/veapig/__init__.py → integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/agent.py}

@@ -12,6 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .apig import APIGateway
+from {{ cookiecutter.app_name|replace('-', '_') }}.agent import agent # type: ignore
 
-__all__ = ["APIGateway"]
+from veadk.memory.short_term_memory import ShortTermMemory
+from veadk.types import AgentRunConfig
+
+# [required] instantiate the agent run configuration
+agent_run_config = AgentRunConfig(
+    app_name="{{ cookiecutter.app_name }}",
+    agent=agent, # type: ignore
+    short_term_memory=ShortTermMemory(backend="{{ cookiecutter.short_term_memory_backend }}"), # type: ignore
+)

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/app.py

@@ -0,0 +1,146 @@
+# 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 os
+from contextlib import asynccontextmanager
+from typing import Callable
+
+from agent import agent_run_config
+from fastapi import FastAPI
+from fastmcp import FastMCP
+
+from veadk.a2a.ve_a2a_server import init_app
+from veadk.runner import Runner
+from veadk.tracing.telemetry.exporters.apmplus_exporter import APMPlusExporter
+from veadk.tracing.telemetry.exporters.cozeloop_exporter import CozeloopExporter
+from veadk.tracing.telemetry.exporters.tls_exporter import TLSExporter
+from veadk.tracing.telemetry.opentelemetry_tracer import OpentelemetryTracer
+from veadk.types import AgentRunConfig
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+assert isinstance(agent_run_config, AgentRunConfig), (
+    f"Invalid agent_run_config type: {type(agent_run_config)}, expected `AgentRunConfig`"
+)
+
+app_name = agent_run_config.app_name
+agent = agent_run_config.agent
+short_term_memory = agent_run_config.short_term_memory
+
+
+def load_tracer() -> None:
+    EXPORTER_REGISTRY = {
+        "VEADK_TRACER_APMPLUS": APMPlusExporter,
+        "VEADK_TRACER_COZELOOP": CozeloopExporter,
+        "VEADK_TRACER_TLS": TLSExporter,
+    }
+
+    exporters = []
+    for env_var, exporter_cls in EXPORTER_REGISTRY.items():
+        if os.getenv(env_var, "").lower() == "true":
+            if (
+                agent.tracers
+                and isinstance(agent.tracers[0], OpentelemetryTracer)
+                and any(isinstance(e, exporter_cls) for e in agent.tracers[0].exporters)
+            ):
+                logger.warning(
+                    f"Exporter {exporter_cls.__name__} is already defined in agent.tracers[0].exporters. These two exporters will be used at the same time. As a result, your data may be uploaded twice."
+                )
+            else:
+                exporters.append(exporter_cls())
+
+    tracer = OpentelemetryTracer(
+        name="veadk_tracer", app_name=agent_run_config.app_name, exporters=exporters
+    )
+    agent_run_config.agent.tracers.extend([tracer])
+    tracer.do_hooks(agent=agent_run_config.agent)
+
+
+def build_mcp_run_agent_func() -> Callable:
+    runner = Runner(
+        agent=agent,
+        short_term_memory=short_term_memory,
+        app_name=app_name,
+        user_id="",
+    )
+
+    async def run_agent(
+        user_input: str,
+        user_id: str = "mcp_user",
+        session_id: str = "mcp_session",
+    ) -> str:
+        # Set user_id for runner
+        runner.user_id = user_id
+
+        # Running agent and get final output
+        final_output = await runner.run(
+            messages=user_input,
+            session_id=session_id,
+        )
+        return final_output
+
+    run_agent_doc = f"""{agent.description}
+    Args:
+        user_input: User's input message (required).
+        user_id: User identifier. Defaults to "mcp_user".
+        session_id: Session identifier. Defaults to "mcp_session".
+    Returns:
+        Final agent response as a string."""
+
+    run_agent.__doc__ = run_agent_doc
+
+    return run_agent
+
+
+load_tracer()
+
+a2a_app = init_app(
+    server_url="0.0.0.0",
+    app_name=app_name,
+    agent=agent,
+    short_term_memory=short_term_memory,
+)
+
+# Build a run_agent function for building MCP server
+run_agent_func = build_mcp_run_agent_func()
+a2a_app.post("/run_agent", operation_id="run_agent", tags=["mcp"])(run_agent_func)
+
+
+# === Build mcp server ===
+
+mcp = FastMCP.from_fastapi(app=a2a_app, name=app_name, include_tags={"mcp"})
+
+# Create MCP ASGI app
+mcp_app = mcp.http_app(path="/", transport="streamable-http")
+
+
+# Combined lifespan management
+@asynccontextmanager
+async def combined_lifespan(app: FastAPI):
+    async with mcp_app.lifespan(app):
+        yield
+
+
+# Create main FastAPI app with combined lifespan
+app = FastAPI(title=a2a_app.title, version=a2a_app.version, lifespan=combined_lifespan)
+
+# Mount A2A routes to main app
+for route in a2a_app.routes:
+    app.routes.append(route)
+
+# Mount MCP server at /mcp endpoint
+app.mount("/mcp", mcp_app)
+
+# === Build mcp server end ===

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/requirements.txt

@@ -0,0 +1 @@
+veadk-python

veadk/{cli/services/vefaas/template → integrations/ve_faas/template/{{cookiecutter.local_dir_name}}}/src/run.sh

@@ -38,26 +38,17 @@ python3 -m pip install uvicorn[standard]
 
 python3 -m pip install fastapi
 
-USE_STUDIO=${USE_STUDIO:-False}
+python3 -m pip install fastmcp
+
 USE_ADK_WEB=${USE_ADK_WEB:-False}
 
-if [ "$USE_STUDIO" = "True" ]; then
-    echo "USE_STUDIO is True, running veadk studio"
-    # running veadk studio
-    exec python3 -m uvicorn studio_app:app --host $HOST --port $PORT --timeout-graceful-shutdown $TIMEOUT --loop asyncio
-elif [ "$USE_STUDIO" = "False" ]; then
-    echo "USE_STUDIO is False"
-
-    if [ "$USE_ADK_WEB" = "True" ]; then
-        echo "USE_ADK_WEB is True, running veadk web"
-        # running veadk web
-        cd ../
-        exec python3 -m veadk.cli.main web --host "0.0.0.0"
-    else
-        echo "USE_ADK_WEB is False, running a2a server"
-        exec python3 -m uvicorn app:app --host $HOST --port $PORT --timeout-graceful-shutdown $TIMEOUT --loop asyncio
-    fi
+export SHORT_TERM_MEMORY_BACKEND= # can be `mysql`
+export LONG_TERM_MEMORY_BACKEND= # can be `opensearch`
+
+if [ "$USE_ADK_WEB" = "True" ]; then
+    echo "USE_ADK_WEB is True, running veadk web"
+    exec python3 -m veadk.cli.cli web --host $HOST
 else
-    # running a2a server
+    echo "USE_ADK_WEB is False, running A2A and MCP server"
     exec python3 -m uvicorn app:app --host $HOST --port $PORT --timeout-graceful-shutdown $TIMEOUT --loop asyncio
-fi
+fi

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/{{ cookiecutter.app_name|replace('-', '_') }}/__init__.py

@@ -0,0 +1,14 @@
+#
+# 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 . import agent  # noqa

veadk/{cli/services/vefaas/template/src/agent.py → integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/{{ cookiecutter.app_name|replace('-', '_') }}/agent.py }

@@ -13,13 +13,15 @@
 # limitations under the License.
 
 from veadk import Agent
-from veadk.memory.short_term_memory import ShortTermMemory
 from veadk.tools.demo_tools import get_city_weather
 
-app_name: str = "weather-reporter"  # <--- export your app name
-agent: Agent = Agent(tools=[get_city_weather])  # <--- export your agent
-short_term_memory: ShortTermMemory = (
-    ShortTermMemory()
-)  # <--- export your short term memory
+# define your agent here
+agent: Agent = Agent(
+    name="weather_reporter",
+    description="A reporter for weather updates",
+    instruction="Once user ask you weather of a city, you need to provide the weather report for that city by calling `get_city_weather`.",
+    tools=[get_city_weather],
+)
 
+# required from Google ADK Web
 root_agent = agent

veadk/{cli/services/vefaas/vefaas.py → integrations/ve_faas/ve_faas.py}

@@ -27,13 +27,15 @@ from volcenginesdkvefaas.models.tag_for_create_function_input import (
 )
 
 import veadk.config
-from veadk.cli.services.veapig.apig import APIGateway
+from veadk.integrations.ve_apig.ve_apig import APIGateway
+from veadk.integrations.ve_faas.ve_faas_utils import (
+    signed_request,
+    zip_and_encode_folder,
+)
 from veadk.utils.logger import get_logger
 from veadk.utils.misc import formatted_timestamp
 from veadk.utils.volcengine_sign import ve_request
 
-from .vefaas_utils import signed_request, zip_and_encode_folder
-
 logger = get_logger(__name__)
 
 
@@ -118,6 +120,8 @@ class VeFaaS:
                 envs=envs,
             )
         )
+        logger.debug(f"Function creation response: {res}")
+
         function_id = res.id
 
         # Upload and mount code using extracted method
@@ -155,9 +159,14 @@ class VeFaaS:
             region="cn-beijing",
             host="open.volcengineapi.com",
         )
-        assert response["Result"]["Status"] == "create_success"
 
-        return response["Result"]["Id"]
+        try:
+            if response["Result"]["Status"] == "create_success":
+                return response["Result"]["Id"]
+            else:
+                raise ValueError(f"Create application failed: {response}")
+        except Exception as _:
+            raise ValueError(f"Create application failed: {response}")
 
     def _release_application(self, app_id: str):
         _ = ve_request(
@@ -171,7 +180,6 @@ class VeFaaS:
             host="open.volcengineapi.com",
         )
 
-        logger.info(f"Start to release VeFaaS application {app_id}.")
         status, full_response = self._get_application_status(app_id)
         while status not in ["deploy_success", "deploy_fail"]:
             time.sleep(10)
@@ -304,6 +312,7 @@ class VeFaaS:
         for app in apps:
             if app["Name"] == name:
                 return app["Id"]
+        logger.warning(f"Application with name {name} not found.")
         return None
 
     def delete(self, app_id: str):

veadk/integrations/ve_prompt_pilot/__init__.py

@@ -0,0 +1,13 @@
+# 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.

veadk/{cli/services/agentpilot/agentpilot.py → integrations/ve_prompt_pilot/ve_prompt_pilot.py}

@@ -24,11 +24,12 @@ from veadk.utils.logger import get_logger
 logger = get_logger(__name__)
 
 
-class AgentPilot:
-    def __init__(self, api_key: str, path: str = "", task_id: str = None) -> None:
+class VePromptPilot:
+    def __init__(
+        self, api_key: str, path: str = "", task_id: str | None = None
+    ) -> None:
         self.api_key = api_key
         self.path = path
-        self.task_id = task_id
 
     def optimize(
         self,
@@ -38,7 +39,7 @@ class AgentPilot:
     ) -> str:
         for idx, agent in enumerate(agents):
             optimized_prompt = ""
-            if feedback == "":
+            if not feedback:
                 logger.info("Optimizing prompt without feedback.")
                 task_description = prompt_optimization.render_prompt_with_jinja2(agent)
             else:
@@ -73,5 +74,3 @@ class AgentPilot:
             logger.info(f"Token usage: {usage['total_tokens']}")
 
         return optimized_prompt
-        return optimized_prompt
-        return optimized_prompt

veadk/knowledgebase/knowledgebase.py

@@ -32,9 +32,7 @@ class KnowledgeBase:
         top_k: int = 10,
         db_config=None,
     ):
-        logger.info(
-            f"Initializing knowledgebase: backend={backend} top_k={top_k} db_config={db_config}"
-        )
+        logger.info(f"Initializing knowledgebase: backend={backend} top_k={top_k}")
 
         self.backend = backend
         self.top_k = top_k
@@ -43,7 +41,7 @@ class KnowledgeBase:
         self.adapter = get_knowledgebase_database_adapter(self.db_client)
 
         logger.info(
-            f"Initialized knowledgebase: db_client={self.db_client} adapter={self.adapter}"
+            f"Initialized knowledgebase: db_client={self.db_client.__class__.__name__} adapter={self.adapter}"
         )
 
     def add(
@@ -71,7 +69,7 @@ class KnowledgeBase:
 
         self.adapter.add(data=data, index=index)
 
-    def search(self, query: str, app_name: str, top_k: int = None) -> list[str]:
+    def search(self, query: str, app_name: str, top_k: int | None = None) -> list[str]:
         top_k = self.top_k if top_k is None else top_k
 
         logger.info(

veadk/memory/long_term_memory.py

@@ -41,11 +41,14 @@ class LongTermMemory(BaseMemoryService):
     def __init__(
         self,
         backend: Literal[
-            "local", "opensearch", "redis", "mysql", "viking"
+            "local", "opensearch", "redis", "mysql", "viking", "viking_mem"
         ] = "opensearch",
         top_k: int = 5,
     ):
         if backend == "viking":
+            logger.warning(
+                "`viking` backend is deprecated, switching to `viking_mem` backend."
+            )
             backend = "viking_mem"
         self.top_k = top_k
         self.backend = backend
@@ -60,7 +63,7 @@ class LongTermMemory(BaseMemoryService):
         self.adapter = get_long_term_memory_database_adapter(self.db_client)
 
         logger.info(
-            f"Initialized long term memory: db_client={self.db_client} adapter={self.adapter}"
+            f"Initialized long term memory: db_client={self.db_client.__class__.__name__} adapter={self.adapter}"
         )
 
     def _filter_and_convert_events(self, events: list[Event]) -> list[str]:

veadk/memory/short_term_memory.py

@@ -60,18 +60,14 @@ class ShortTermMemory:
             self.session_service = InMemorySessionService()
         elif self.backend == "database":
             if self.db_url == "" or self.db_url is None:
-                logger.warning(
-                    f"The `db_url` {self.db_url} is an empty or None string."
-                )
+                logger.warning("The `db_url` is an empty or None string.")
                 self._use_default_database()
             else:
                 try:
                     self.session_service = DatabaseSessionService(db_url=self.db_url)
-                    logger.info("Connected to database.")
+                    logger.info("Connected to database with db_url.")
                 except Exception as e:
-                    logger.error(
-                        f"Failed to connect to database {self.db_url}, error: {e}."
-                    )
+                    logger.error(f"Failed to connect to database, error: {e}.")
                     self._use_default_database()
         else:
             raise ValueError(f"Unknown short term memory backend: {self.backend}")