veadk-python 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

veadk/cli/cli_deploy.py

@@ -14,6 +14,7 @@
 
 
 import click
+
 from veadk.version import VERSION
 
 TEMP_PATH = "/tmp"
@@ -86,8 +87,8 @@ def deploy(
     tmp_dir_name = f"{user_proj_abs_path.name}_{formatted_timestamp()}"
 
     settings = {
-        "local_dir_name": tmp_dir_name,
-        "app_name": user_proj_abs_path.name,
+        "local_dir_name": tmp_dir_name.replace("-", "_"),
+        "app_name": user_proj_abs_path.name.replace("-", "_"),
         "agent_module_name": user_proj_abs_path.name,
         "short_term_memory_backend": short_term_memory_backend,
         "vefaas_application_name": vefaas_app_name,

veadk/cli/cli_eval.py

@@ -0,0 +1,160 @@
+# 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 click
+
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.command()
+@click.option(
+    "--agent-dir",
+    default=".",
+    help="To-be-evaluated agent directory. Must export `root_agent` in `agent.py`",
+)
+@click.option(
+    "--agent-a2a-url",
+    default=None,
+    help="To-be-evaluated agent URL. The agent should be deployed as A2A mode.",
+)
+@click.option(
+    "--evalset-file",
+    required=True,
+    help="Google ADK formatted evalset file path",
+)
+@click.option(
+    "--evaluator",
+    type=click.Choice(["adk", "deepeval"], case_sensitive=False),
+    help="Evaluator type, choose `adk` or `deepeval`",
+)
+@click.option(
+    "--judge-model-name",
+    default="doubao-1-5-pro-256k-250115",
+    help="Judge model name, default is `doubao-1-5-pro-256k-250115`. Useless under `adk` evaluator.",
+)
+@click.option(
+    "--volcengine-access-key",
+    default=None,
+    help="Volcengine access key for using Volcengine models",
+)
+@click.option(
+    "--volcengine-secret-key",
+    default=None,
+    help="Volcengine secret key for using Volcengine models",
+)
+def eval(
+    agent_dir: str,
+    agent_a2a_url: str,
+    evalset_file: str,
+    evaluator: str,
+    judge_model_name: str,
+    volcengine_access_key: str,
+    volcengine_secret_key: str,
+) -> None:
+    import asyncio
+    import os
+    from pathlib import Path
+
+    from google.adk.cli.utils.agent_loader import AgentLoader
+
+    from veadk.a2a.remote_ve_agent import RemoteVeAgent
+    from veadk.config import getenv, settings
+    from veadk.prompts.prompt_evaluator import eval_principle_prompt
+
+    try:
+        from deepeval.metrics import GEval, ToolCorrectnessMetric
+        from deepeval.test_case import LLMTestCaseParams
+
+        from veadk.evaluation.adk_evaluator import ADKEvaluator
+        from veadk.evaluation.deepeval_evaluator import DeepevalEvaluator
+    except ImportError:
+        raise ImportError(
+            "Please install veadk with `[evaluation]` extras, e.g., `pip install veadk-python[eval]`"
+        )
+
+    # ====== prepare agent instance ======
+    if not agent_dir and not agent_a2a_url:
+        raise ValueError(
+            "Option `--agent-dir` or  `--agent-a2a-url` should be provided one of them."
+        )
+
+    if agent_dir and agent_a2a_url:
+        logger.warning(
+            "`--agent-dir` and `--agent-a2a-url` are both provided, will use `--agent-a2a-url`."
+        )
+        agent_instance = RemoteVeAgent(name="a2a_agent", url=agent_a2a_url)
+        logger.info(f"Loaded agent from {agent_a2a_url}")
+
+    if not agent_dir and agent_a2a_url:
+        agent_instance = RemoteVeAgent(name="a2a_agent", url=agent_a2a_url)
+        logger.info(f"Loaded agent from {agent_a2a_url}")
+
+    if agent_dir and not agent_a2a_url:
+        agent_instance = AgentLoader(str(Path(agent_dir).parent.resolve())).load_agent(
+            str(Path(agent_dir).name)
+        )
+        logger.info(f"Loaded agent from {agent_dir}, agent name: {agent_instance.name}")
+
+    # ====== prepare envs ======
+    if volcengine_access_key and "VOLCENGINE_ACCESS_KEY" not in os.environ:
+        os.environ["VOLCENGINE_ACCESS_KEY"] = volcengine_access_key
+    if volcengine_secret_key and "VOLCENGINE_SECRET_KEY" not in os.environ:
+        os.environ["VOLCENGINE_SECRET_KEY"] = volcengine_secret_key
+
+    # ====== prepare evaluator instance ======
+    evaluator_instance = None
+    if evaluator == "adk" and judge_model_name:
+        logger.warning(
+            "Using Google ADK evaluator, `--judge-model-name` will be ignored."
+        )
+        evaluator_instance = ADKEvaluator(agent=agent_instance)
+
+        asyncio.run(evaluator_instance.evaluate(eval_set_file_path=evalset_file))
+
+    if evaluator == "deepeval":
+        if not volcengine_access_key:
+            volcengine_access_key = getenv("VOLCENGINE_ACCESS_KEY")
+        if not volcengine_secret_key:
+            volcengine_secret_key = getenv("VOLCENGINE_SECRET_KEY")
+
+        evaluator_instance = DeepevalEvaluator(
+            agent=agent_instance,
+            judge_model_api_key=settings.model.api_key,
+            judge_model_name=judge_model_name,
+        )
+
+        judge_model = evaluator_instance.judge_model
+
+        metrics = [
+            GEval(
+                threshold=0.8,
+                name="Base Evaluation",
+                criteria=eval_principle_prompt,
+                evaluation_params=[
+                    LLMTestCaseParams.INPUT,
+                    LLMTestCaseParams.ACTUAL_OUTPUT,
+                    LLMTestCaseParams.EXPECTED_OUTPUT,
+                ],
+                model=judge_model,
+            ),
+            ToolCorrectnessMetric(threshold=0.5),
+        ]
+
+        asyncio.run(
+            evaluator_instance.evaluate(
+                eval_set_file_path=evalset_file, metrics=metrics
+            )
+        )

veadk/cli/cli_init.py

@@ -16,8 +16,8 @@ import warnings
 from typing import Any
 
 import click
-from veadk.version import VERSION
 
+from veadk.version import VERSION
 
 warnings.filterwarnings(
     "ignore", category=UserWarning, module="pydantic._internal._fields"

veadk/cli/cli_pipeline.py

@@ -0,0 +1,220 @@
+# 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 warnings
+
+import click
+
+from veadk.config import getenv
+from veadk.consts import (
+    DEFAULT_CR_INSTANCE_NAME,
+    DEFAULT_CR_NAMESPACE_NAME,
+    DEFAULT_CR_REPO_NAME,
+)
+from veadk.integrations.ve_code_pipeline.ve_code_pipeline import VeCodePipeline
+from veadk.integrations.ve_cr.ve_cr import VeCR
+from veadk.integrations.ve_faas.ve_faas import VeFaaS
+from veadk.utils.logger import get_logger
+from veadk.version import VERSION
+
+logger = get_logger(__name__)
+
+
+warnings.filterwarnings(
+    "ignore", category=UserWarning, module="pydantic._internal._fields"
+)
+
+
+def _create_cr(volcengine_settings: dict[str, str], cr_settings: dict[str, str]):
+    vecr = VeCR(
+        access_key=volcengine_settings["volcengine_access_key"],
+        secret_key=volcengine_settings["volcengine_secret_key"],
+        region=volcengine_settings["volcengine_region"],
+    )
+    try:
+        vecr._create_instance(cr_settings["cr_instance_name"])
+    except Exception as e:
+        click.echo(f"Failed to create CR instance: {e}")
+        raise
+
+    try:
+        vecr._create_namespace(
+            instance_name=cr_settings["cr_instance_name"],
+            namespace_name=cr_settings["cr_namespace_name"],
+        )
+    except Exception as e:
+        click.echo(f"Failed to create CR namespace: {e}")
+        raise
+
+    try:
+        vecr._create_repo(
+            instance_name=cr_settings["cr_instance_name"],
+            namespace_name=cr_settings["cr_namespace_name"],
+            repo_name=cr_settings["cr_repo_name"],
+        )
+    except Exception as e:
+        click.echo(f"Failed to create CR repo: {e}")
+        raise
+
+
+@click.command()
+@click.option(
+    "--veadk-version",
+    default=VERSION,
+    help=f"Base VeADK image tag can be 'preview', 'latest', or a specific VeADK version (e.g., {VERSION})",
+)
+@click.option(
+    "--github-url",
+    required=True,
+    help="The github url of your project",
+)
+@click.option(
+    "--github-branch",
+    required=True,
+    help="The github branch of your project",
+)
+@click.option(
+    "--github-token",
+    required=True,
+    help="The github token to manage your project",
+)
+@click.option(
+    "--volcengine-access-key",
+    default=None,
+    help="Volcengine access key, if not set, will use the value of environment variable VOLCENGINE_ACCESS_KEY",
+)
+@click.option(
+    "--volcengine-secret-key",
+    default=None,
+    help="Volcengine secret key, if not set, will use the value of environment variable VOLCENGINE_SECRET_KEY",
+)
+@click.option(
+    "--region",
+    default="cn-beijing",
+    help="Region for Volcengine VeFaaS, CR, and Pipeline. Default is cn-beijing",
+)
+@click.option(
+    "--cr-instance-name",
+    default=DEFAULT_CR_INSTANCE_NAME,
+    help="Volcengine Container Registry instance name, default is veadk-user-instance",
+)
+@click.option(
+    "--cr-namespace-name",
+    default=DEFAULT_CR_NAMESPACE_NAME,
+    help="Volcengine Container Registry namespace name, default is veadk-user-namespace",
+)
+@click.option(
+    "--cr-repo-name",
+    default=DEFAULT_CR_REPO_NAME,
+    help="Volcengine Container Registry repo name, default is veadk-user-repo",
+)
+@click.option(
+    "--vefaas-function-id",
+    default=None,
+    help="Volcengine FaaS function ID, if not set, a new function will be created automatically",
+)
+def pipeline(
+    veadk_version: str,
+    github_url: str,
+    github_branch: str,
+    github_token: str,
+    volcengine_access_key: str,
+    volcengine_secret_key: str,
+    region: str,
+    cr_instance_name: str,
+    cr_namespace_name: str,
+    cr_repo_name: str,
+    vefaas_function_id: str,
+) -> None:
+    """Integrate a veadk project to volcengine pipeline for CI/CD"""
+
+    click.echo(
+        "Welcome use VeADK to integrate your project to volcengine pipeline for CI/CD."
+    )
+
+    if not volcengine_access_key:
+        volcengine_access_key = getenv("VOLCENGINE_ACCESS_KEY")
+    if not volcengine_secret_key:
+        volcengine_secret_key = getenv("VOLCENGINE_SECRET_KEY")
+
+    volcengine_settings = {
+        "volcengine_access_key": volcengine_access_key,
+        "volcengine_secret_key": volcengine_secret_key,
+        "volcengine_region": region,
+    }
+
+    cr_settings = {
+        "cr_domain": f"{cr_instance_name}-{region}.cr.volces.com",
+        "cr_instance_name": cr_instance_name,
+        "cr_namespace_name": cr_namespace_name,
+        "cr_repo_name": cr_repo_name,
+        "cr_region": region,
+    }
+
+    if not vefaas_function_id:
+        click.echo(
+            "No Function ID specified. VeADK will create one automatically. Please specify a function name:"
+        )
+        function_name = click.prompt(
+            "Function name", default="veadk-image-function", show_default=False
+        )
+
+    _create_cr(volcengine_settings, cr_settings)
+
+    if not vefaas_function_id:
+        vefaas_client = VeFaaS(
+            access_key=volcengine_settings["volcengine_access_key"],
+            secret_key=volcengine_settings["volcengine_secret_key"],
+            region=volcengine_settings["volcengine_region"],
+        )
+        _, _, function_id = vefaas_client.deploy_image(
+            name=function_name,
+            image="veadk-cn-beijing.cr.volces.com/veadk/simple-fastapi:0.1",
+            registry_name=cr_settings["cr_instance_name"],
+        )
+        logger.debug(f"Created function {function_name} with ID: {function_id}")
+
+    client = VeCodePipeline(
+        volcengine_access_key=volcengine_settings["volcengine_access_key"],
+        volcengine_secret_key=volcengine_settings["volcengine_secret_key"],
+        region=volcengine_settings["volcengine_region"],
+    )
+
+    click.echo("=====================================================")
+    click.echo("Using the following configuration to create pipeline:")
+    click.echo(f"Use VeADK version: {veadk_version}")
+    click.echo(f"Github url: {github_url}")
+    click.echo(f"Github branch: {github_branch}")
+    click.echo(f"VeFaaS function name: {function_name}")
+    click.echo(f"VeFaaS function ID: {function_id}")
+    click.echo(f"Container Registry domain: {cr_settings['cr_domain']}")
+    click.echo(f"Container Registry namespace name: {cr_settings['cr_namespace_name']}")
+    click.echo(f"Container Registry region: {region}")
+    click.echo(f"Container Registry instance name: {cr_settings['cr_instance_name']}")
+    click.echo(f"Container Registry repo name: {cr_settings['cr_repo_name']}")
+
+    client.deploy(
+        base_image_tag=veadk_version,
+        github_url=github_url,
+        github_branch=github_branch,
+        github_token=github_token,
+        cr_domain=cr_settings["cr_domain"],
+        cr_namespace_name=cr_settings["cr_namespace_name"],
+        cr_region=cr_settings["cr_region"],
+        cr_instance_name=cr_settings["cr_instance_name"],
+        cr_repo_name=cr_settings["cr_repo_name"],
+        function_id=function_id,
+    )
+
+    click.echo("Pipeline has been created successfully.")

veadk/cli/cli_prompt.py

@@ -19,8 +19,8 @@ import click
 @click.option(
     "--path", default=".", help="Agent file path with global variable `agent=...`"
 )
-@click.option("--feedback", default=None, help="Suggestions for prompt optimization")
-@click.option("--api-key", default=None, help="API Key of PromptPilot")
+@click.option("--feedback", default="", help="Suggestions for prompt optimization")
+@click.option("--api-key", default="", help="API Key of PromptPilot")
 @click.option(
     "--model-name",
     default="doubao-1.5-pro-32k-250115",
@@ -31,7 +31,7 @@ def prompt(path: str, feedback: str, api_key: str, model_name: str) -> None:
     from pathlib import Path
 
     from veadk.agent import Agent
-    from veadk.config import getenv
+    from veadk.config import settings
     from veadk.integrations.ve_prompt_pilot.ve_prompt_pilot import VePromptPilot
     from veadk.utils.misc import load_module_from_file
 
@@ -55,7 +55,7 @@ def prompt(path: str, feedback: str, api_key: str, model_name: str) -> None:
         click.echo(f"Found {len(agents)} agents in {module_abs_path}")
 
         if not api_key:
-            api_key = getenv("PROMPT_PILOT_API_KEY")
+            api_key = settings.prompt_pilot.api_key
         ve_prompt_pilot = VePromptPilot(api_key)
         ve_prompt_pilot.optimize(
             agents=agents, feedback=feedback, model_name=model_name

veadk/cli/cli_web.py

@@ -178,4 +178,6 @@ def web(host: str) -> None:
     agents_dir = os.getcwd()
     logger.info(f"Load agents from {agents_dir}")
 
-    cli_tools_click.cli_web.main(args=[agents_dir, "--host", host])
+    cli_tools_click.cli_web.main(
+        args=[agents_dir, "--host", host, "--log_level", "ERROR"]
+    )

veadk/config.py

@@ -13,95 +13,48 @@
 # limitations under the License.
 
 import os
-from typing import Any, Dict, List, MutableMapping, Tuple
+from typing import Any
 
 from dotenv import find_dotenv
-from pydantic_settings import (
-    BaseSettings,
-    InitSettingsSource,
-    PydanticBaseSettingsSource,
-    SettingsConfigDict,
-    YamlConfigSettingsSource,
+from pydantic import BaseModel, Field
+
+from veadk.configs.database_configs import (
+    MysqlConfig,
+    OpensearchConfig,
+    RedisConfig,
+    TOSConfig,
+    VikingKnowledgebaseConfig,
 )
+from veadk.configs.model_configs import ModelConfig
+from veadk.configs.tool_configs import BuiltinToolConfigs, PromptPilotConfig
+from veadk.configs.tracing_configs import (
+    APMPlusConfig,
+    CozeloopConfig,
+    PrometheusConfig,
+    TLSConfig,
+)
+from veadk.utils.misc import set_envs
 
-settings = None
-veadk_environments = {}
-
-
-def flatten_dict(
-    d: MutableMapping[str, Any], parent_key: str = "", sep: str = "_"
-) -> Dict[str, Any]:
-    """Flatten a nested dictionary, using a separator in the keys.
-    Useful for pydantic_v1 models with nested fields -- first use
-        dct = mdl.model_dump()
-    to get a nested dictionary, then use this function to flatten it.
-    """
-    items: List[Tuple[str, Any]] = []
-    for k, v in d.items():
-        new_key = f"{parent_key}{sep}{k}" if parent_key else k
-        if isinstance(v, MutableMapping):
-            items.extend(flatten_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        yaml_file=find_dotenv(filename="config.yaml", usecwd=True), extra="allow"
-    )
-
-    @classmethod
-    def settings_customise_sources(
-        cls,
-        settings_cls: type[BaseSettings],
-        init_settings: PydanticBaseSettingsSource,
-        env_settings: PydanticBaseSettingsSource,
-        dotenv_settings: PydanticBaseSettingsSource,
-        file_secret_settings: PydanticBaseSettingsSource,
-    ) -> tuple[PydanticBaseSettingsSource, ...]:
-        yaml_source = YamlConfigSettingsSource(settings_cls)
-        raw_data = yaml_source()
-        flat_data = flatten_dict(raw_data)
-
-        init_source = InitSettingsSource(settings_cls, flat_data)
-        return (
-            init_source,
-            env_settings,
-            dotenv_settings,
-            file_secret_settings,
-        )
-
-
-def prepare_settings():
-    path = find_dotenv(filename="config.yaml", usecwd=True)
-
-    if path == "" or path is None or not os.path.exists(path):
-        # logger.warning(
-        #     "Default and recommanded config file `config.yaml` not found. Please put it in the root directory of your project."
-        # )
-        pass
-    else:
-        # logger.info(f"Loading config file from {path}")
-        global settings
-        settings = Settings()
-
-        for k, v in settings.model_dump().items():
-            global veadk_environments
-
-            k = k.upper()
-            if k in os.environ:
-                veadk_environments[k] = os.environ[k]
-                continue
-            veadk_environments[k] = str(v)
-            os.environ[k] = str(v)
 
+class VeADKConfig(BaseModel):
+    model: ModelConfig = Field(default_factory=ModelConfig)
+    """Config for agent reasoning model."""
 
-prepare_settings()
+    tool: BuiltinToolConfigs = Field(default_factory=BuiltinToolConfigs)
+    prompt_pilot: PromptPilotConfig = Field(default_factory=PromptPilotConfig)
 
+    apmplus_config: APMPlusConfig = Field(default_factory=APMPlusConfig)
+    cozeloop_config: CozeloopConfig = Field(default_factory=CozeloopConfig)
+    tls_config: TLSConfig = Field(default_factory=TLSConfig)
+    prometheus_config: PrometheusConfig = Field(default_factory=PrometheusConfig)
 
-def get_envlist():
-    return os.environ.keys()
+    tos: TOSConfig = Field(default_factory=TOSConfig)
+    opensearch: OpensearchConfig = Field(default_factory=OpensearchConfig)
+    mysql: MysqlConfig = Field(default_factory=MysqlConfig)
+    redis: RedisConfig = Field(default_factory=RedisConfig)
+    viking_knowledgebase: VikingKnowledgebaseConfig = Field(
+        default_factory=VikingKnowledgebaseConfig
+    )
 
 
 def getenv(
@@ -129,3 +82,14 @@ def getenv(
         raise ValueError(
             f"The environment variable `{env_name}` not exists. Please set this in your environment variable or config.yaml."
         )
+
+
+config_yaml_path = find_dotenv(filename="config.yaml", usecwd=True)
+
+veadk_environments = {}
+
+if config_yaml_path:
+    config_dict, _veadk_environments = set_envs(config_yaml_path=config_yaml_path)
+    veadk_environments.update(_veadk_environments)
+
+settings = VeADKConfig()