veadk-python 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

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/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()

veadk/configs/__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/configs/database_configs.py

@@ -0,0 +1,83 @@
+# 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 functools import cached_property
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from veadk.consts import DEFAULT_TOS_BUCKET_NAME
+from veadk.integrations.ve_tos.ve_tos import VeTOS
+
+
+class OpensearchConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_OPENSEARCH_")
+
+    host: str = ""
+
+    port: int = 9200
+
+    username: str = ""
+
+    password: str = ""
+
+
+class MysqlConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_MYSQL_")
+
+    host: str = ""
+
+    user: str = ""
+
+    password: str = ""
+
+    database: str = ""
+
+    charset: str = "utf8"
+
+
+class RedisConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_REDIS_")
+
+    host: str = ""
+
+    port: int = 6379
+
+    password: str = ""
+
+    db: int = 0
+
+
+class VikingKnowledgebaseConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_VIKING_")
+
+    project: str = "default"
+    """User project in Volcengine console web."""
+
+    region: str = "cn-beijing"
+
+
+class TOSConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_TOS_")
+
+    endpoint: str = "tos-cn-beijing.volces.com"
+
+    region: str = "cn-beijing"
+
+    @cached_property
+    def bucket(self) -> str:
+        _bucket = os.getenv("DATABASE_TOS_BUCKET") or DEFAULT_TOS_BUCKET_NAME
+
+        VeTOS(bucket_name=_bucket).create_bucket()
+        return _bucket

veadk/configs/model_configs.py

@@ -0,0 +1,42 @@
+# 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 functools import cached_property
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from veadk.auth.veauth.ark_veauth import ARKVeAuth
+from veadk.consts import (
+    DEFAULT_MODEL_AGENT_API_BASE,
+    DEFAULT_MODEL_AGENT_NAME,
+    DEFAULT_MODEL_AGENT_PROVIDER,
+)
+
+
+class ModelConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="MODEL_AGENT_")
+
+    name: str = DEFAULT_MODEL_AGENT_NAME
+    """Model name for agent reasoning."""
+
+    provider: str = DEFAULT_MODEL_AGENT_PROVIDER
+    """Model provider for LiteLLM initialization."""
+
+    api_base: str = DEFAULT_MODEL_AGENT_API_BASE
+    """The api base of the model for agent reasoning."""
+
+    @cached_property
+    def api_key(self) -> str:
+        return os.getenv("MODEL_AGENT_API_KEY") or ARKVeAuth().token

veadk/configs/tool_configs.py

@@ -0,0 +1,42 @@
+# 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 functools import cached_property
+
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from veadk.auth.veauth.prompt_pilot_veauth import PromptPilotVeAuth
+from veadk.auth.veauth.vesearch_veauth import VesearchVeAuth
+
+
+class PromptPilotConfig(BaseModel):
+    @cached_property
+    def api_key(self) -> str:
+        return os.getenv("PROMPT_PILOT_API_KEY") or PromptPilotVeAuth().token
+
+
+class VeSearchConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="TOOL_VESEARCH_")
+
+    endpoint: int | str = ""
+
+    @cached_property
+    def api_key(self) -> str:
+        return os.getenv("TOOL_VESEARCH_API_KEY") or VesearchVeAuth().token
+
+
+class BuiltinToolConfigs(BaseModel):
+    vesearch: VeSearchConfig = Field(default_factory=VeSearchConfig)

veadk/configs/tracing_configs.py

@@ -0,0 +1,110 @@
+# 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 functools import cached_property
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from veadk.auth.veauth.apmplus_veauth import APMPlusVeAuth
+from veadk.consts import (
+    DEFAULT_APMPLUS_OTEL_EXPORTER_ENDPOINT,
+    DEFAULT_APMPLUS_OTEL_EXPORTER_SERVICE_NAME,
+    DEFAULT_COZELOOP_OTEL_EXPORTER_ENDPOINT,
+    DEFAULT_COZELOOP_SPACE_NAME,
+    DEFAULT_TLS_OTEL_EXPORTER_ENDPOINT,
+    DEFAULT_TLS_OTEL_EXPORTER_REGION,
+)
+from veadk.integrations.ve_cozeloop.ve_cozeloop import VeCozeloop
+from veadk.integrations.ve_tls.ve_tls import VeTLS
+
+
+class APMPlusConfig(BaseSettings):
+    otel_exporter_endpoint: str = Field(
+        default=DEFAULT_APMPLUS_OTEL_EXPORTER_ENDPOINT,
+        alias="OBSERVABILITY_OPENTELEMETRY_APMPLUS_ENDPOINT",
+    )
+
+    otel_exporter_service_name: str = Field(
+        default=DEFAULT_APMPLUS_OTEL_EXPORTER_SERVICE_NAME,
+        alias="OBSERVABILITY_OPENTELEMETRY_APMPLUS_SERVICE_NAME",
+    )
+
+    @cached_property
+    def otel_exporter_api_key(self) -> str:
+        return (
+            os.getenv("OBSERVABILITY_OPENTELEMETRY_APMPLUS_API_KEY")
+            or APMPlusVeAuth().token
+        )
+
+
+class CozeloopConfig(BaseSettings):
+    otel_exporter_endpoint: str = Field(
+        default=DEFAULT_COZELOOP_OTEL_EXPORTER_ENDPOINT,
+        alias="OBSERVABILITY_OPENTELEMETRY_COZELOOP_ENDPOINT",
+    )
+
+    otel_exporter_api_key: str = Field(
+        default="", alias="OBSERVABILITY_OPENTELEMETRY_COZELOOP_API_KEY"
+    )
+
+    # TODO: auto fetching via AK/SK pair
+    # @cached_property
+    # def otel_exporter_api_key(self) -> str:
+    #     pass
+
+    @cached_property
+    def otel_exporter_space_id(self) -> str:
+        workspace_id = os.getenv(
+            "OBSERVABILITY_OPENTELEMETRY_COZELOOP_SERVICE_NAME", ""
+        )
+
+        if not workspace_id:
+            # create a default one
+            workspace_id = VeCozeloop(self.otel_exporter_api_key).create_workspace(
+                workspace_name=DEFAULT_COZELOOP_SPACE_NAME
+            )
+
+        return workspace_id
+
+
+class TLSConfig(BaseSettings):
+    otel_exporter_endpoint: str = Field(
+        default=DEFAULT_TLS_OTEL_EXPORTER_ENDPOINT,
+        alias="OBSERVABILITY_OPENTELEMETRY_TLS_ENDPOINT",
+    )
+
+    otel_exporter_region: str = Field(
+        default=DEFAULT_TLS_OTEL_EXPORTER_REGION,
+        alias="OBSERVABILITY_OPENTELEMETRY_TLS_REGION",
+    )
+
+    @cached_property
+    def otel_exporter_topic_id(self) -> str:
+        _topic_id = (
+            os.getenv("OBSERVABILITY_OPENTELEMETRY_TLS_SERVICE_NAME")
+            or VeTLS().get_trace_topic_id()
+        )
+        return _topic_id
+
+
+class PrometheusConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="OBSERVABILITY_PROMETHEUS_")
+
+    pushgateway_url: str = ""
+
+    pushgateway_username: str = ""
+
+    pushgateway_password: str = ""