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

veadk/tools/builtin_tools/video_generate.py

@@ -26,14 +26,15 @@ from volcenginesdkarkruntime.types.content_generation.create_task_content_param
 )
 
 from veadk.config import getenv
+from veadk.consts import DEFAULT_MODEL_AGENT_API_BASE, DEFAULT_VIDEO_MODEL_NAME
 from veadk.utils.logger import get_logger
 from veadk.version import VERSION
 
 logger = get_logger(__name__)
 
 client = Ark(
-    api_key=getenv("MODEL_VIDEO_API_KEY"),
-    base_url=getenv("MODEL_VIDEO_API_BASE"),
+    api_key=getenv("MODEL_AGENT_API_KEY"),
+    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
 )
 
 
@@ -42,7 +43,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         if first_frame_image is None:
             logger.debug("text generation")
             response = client.content_generation.tasks.create(
-                model=getenv("MODEL_VIDEO_NAME"),
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
                     {"type": "text", "text": prompt},
                 ],
@@ -50,7 +51,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         elif last_frame_image is None:
             logger.debug("first frame generation")
             response = client.content_generation.tasks.create(
-                model=getenv("MODEL_VIDEO_NAME"),
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=cast(
                     list[CreateTaskContentParam],  # avoid IDE warning
                     [
@@ -65,7 +66,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         else:
             logger.debug("last frame generation")
             response = client.content_generation.tasks.create(
-                model=getenv("MODEL_VIDEO_NAME"),
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
                     {"type": "text", "text": prompt},
                     {
@@ -194,19 +195,19 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
     batch_size = 10
     success_list = []
     error_list = []
-    tracer = trace.get_tracer("gcp.vertex.agent")
-    with tracer.start_as_current_span("call_llm") as span:
-        input_part = {"role": "user"}
-        output_part = {"message.role": "model"}
-
-        for idx, item in enumerate(params):
-            input_part[f"parts.{idx}.type"] = "text"
-            input_part[f"parts.{idx}.text"] = json.dumps(item, ensure_ascii=False)
-
-        for start_idx in range(0, len(params), batch_size):
-            batch = params[start_idx : start_idx + batch_size]
-            task_dict = {}
+
+    for start_idx in range(0, len(params), batch_size):
+        batch = params[start_idx : start_idx + batch_size]
+        task_dict = {}
+        tracer = trace.get_tracer("gcp.vertex.agent")
+        with tracer.start_as_current_span("call_llm") as span:
+            input_part = {"role": "user"}
+            output_part = {"message.role": "model"}
+            total_tokens = 0
             for idx, item in enumerate(batch):
+                input_part[f"parts.{idx}.type"] = "text"
+                input_part[f"parts.{idx}.text"] = json.dumps(item, ensure_ascii=False)
+
                 video_name = item["video_name"]
                 prompt = item["prompt"]
                 first_frame = item.get("first_frame", None)
@@ -223,7 +224,6 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                     logger.error(f"Error: {e}")
                     error_list.append(video_name)
 
-            total_tokens = 0
             while True:
                 task_list = list(task_dict.keys())
                 if len(task_list) == 0:
@@ -256,29 +256,29 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                         )
                 time.sleep(10)
 
-        add_span_attributes(
-            span,
-            tool_context,
-            input_part=input_part,
-            output_part=output_part,
-            output_tokens=total_tokens,
-            total_tokens=total_tokens,
-            request_model=getenv("MODEL_VIDEO_NAME"),
-            response_model=getenv("MODEL_VIDEO_NAME"),
-        )
-
-        if len(success_list) == 0:
-            return {
-                "status": "error",
-                "success_list": success_list,
-                "error_list": error_list,
-            }
-        else:
-            return {
-                "status": "success",
-                "success_list": success_list,
-                "error_list": error_list,
-            }
+            add_span_attributes(
+                span,
+                tool_context,
+                input_part=input_part,
+                output_part=output_part,
+                output_tokens=total_tokens,
+                total_tokens=total_tokens,
+                request_model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
+                response_model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
+            )
+
+    if len(success_list) == 0:
+        return {
+            "status": "error",
+            "success_list": success_list,
+            "error_list": error_list,
+        }
+    else:
+        return {
+            "status": "success",
+            "success_list": success_list,
+            "error_list": error_list,
+        }
 
 
 def add_span_attributes(

veadk/tools/builtin_tools/web_search.py

@@ -23,6 +23,7 @@ import json
 from urllib.parse import quote
 
 import requests
+from google.adk.tools import ToolContext
 
 from veadk.config import getenv
 from veadk.utils.logger import get_logger
@@ -151,7 +152,7 @@ def request(method, date, query, header, ak, sk, action, body):
     return r.json()
 
 
-def web_search(query: str) -> list[str]:
+def web_search(query: str, tool_context: ToolContext) -> list[str]:
     """Search a query in websites.
 
     Args:
@@ -166,8 +167,14 @@ def web_search(query: str) -> list[str]:
         "Count": 5,
         "NeedSummary": True,
     }
-    ak = getenv("VOLCENGINE_ACCESS_KEY")
-    sk = getenv("VOLCENGINE_SECRET_KEY")
+
+    ak = tool_context.state.get("VOLCENGINE_ACCESS_KEY")
+    if not ak:
+        ak = getenv("VOLCENGINE_ACCESS_KEY")
+
+    sk = tool_context.state.get("VOLCENGINE_SECRET_KEY")
+    if not sk:
+        sk = getenv("VOLCENGINE_SECRET_KEY")
 
     now = datetime.datetime.utcnow()
     response_body = request(

veadk/tools/load_knowledgebase_tool.py

@@ -24,6 +24,10 @@ from pydantic import BaseModel, Field
 from typing_extensions import override
 
 from veadk.knowledgebase import KnowledgeBase
+from veadk.knowledgebase.entry import KnowledgebaseEntry
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 if TYPE_CHECKING:
     from google.adk.models.llm_request import LlmRequest
@@ -32,10 +36,6 @@ if TYPE_CHECKING:
 knowledgebase: KnowledgeBase | None = None
 
 
-class KnowledgebaseEntry(BaseModel):
-    content: str
-
-
 class LoadKnowledgebaseResponse(BaseModel):
     knowledges: list[KnowledgebaseEntry] = Field(default_factory=list)
 
@@ -55,10 +55,7 @@ async def search_knowledgebase(
 ) -> SearchKnowledgebaseResponse:
     """Searches the knowledgebase of the current user."""
     if isinstance(knowledgebase, KnowledgeBase):
-        res = knowledgebase.search(query)
-        entry_list = []
-        for r in res:
-            entry_list.append(KnowledgebaseEntry(content=r))
+        entry_list = knowledgebase.search(query)
         return SearchKnowledgebaseResponse(knowledges=entry_list)
     else:
         return SearchKnowledgebaseResponse(knowledges=[])
@@ -102,6 +99,15 @@ class LoadKnowledgebaseTool(FunctionTool):
 
     def __init__(self):
         super().__init__(load_knowledgebase)
+        global knowledgebase
+        if knowledgebase is None:
+            logger.info(
+                "Get global knowledgebase instance failed, failed to set knowledgebase tool backend."
+            )
+        else:
+            if not self.custom_metadata:
+                self.custom_metadata = {}
+            self.custom_metadata["backend"] = knowledgebase.backend
 
     @override
     def _get_declaration(self) -> types.FunctionDeclaration | None:

veadk/tracing/telemetry/attributes/extractors/llm_attributes_extractors.py

@@ -325,6 +325,10 @@ def llm_gen_ai_operation_name(params: LLMAttributesParams) -> ExtractorResponse:
     return ExtractorResponse(content="chat")
 
 
+def llm_gen_ai_span_kind(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="llm")
+
+
 # def llm_gen_ai_system_message(params: LLMAttributesParams) -> ExtractorResponse:
 #     event_attributes = {
 #         "content": str(params.llm_request.config.system_instruction),
@@ -528,7 +532,7 @@ def llm_gen_ai_request_functions(params: LLMAttributesParams) -> ExtractorRespon
                 f"gen_ai.request.functions.{idx}.name": tool_instance.name,
                 f"gen_ai.request.functions.{idx}.description": tool_instance.description,
                 f"gen_ai.request.functions.{idx}.parameters": str(
-                    tool_instance._get_declaration().parameters.model_dump(  # type: ignore
+                    tool_instance._get_declaration().parameters.model_dump_json(  # type: ignore
                         exclude_none=True
                     )
                     if tool_instance._get_declaration()
@@ -559,6 +563,7 @@ LLM_ATTRIBUTES = {
     "gen_ai.is_streaming": llm_gen_ai_is_streaming,
     # -> 1.4. span kind
     "gen_ai.operation.name": llm_gen_ai_operation_name,
+    "gen_ai.span.kind": llm_gen_ai_span_kind,  # apmplus required
     # -> 1.5. inputs
     "gen_ai.prompt": llm_gen_ai_prompt,
     # -> 1.6. outputs

veadk/tracing/telemetry/attributes/extractors/tool_attributes_extractors.py

@@ -23,6 +23,10 @@ def tool_gen_ai_operation_name(params: ToolAttributesParams) -> ExtractorRespons
     return ExtractorResponse(content="execute_tool")
 
 
+def tool_gen_ai_span_kind(params: ToolAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="tool")
+
+
 def tool_gen_ai_tool_message(params: ToolAttributesParams) -> ExtractorResponse:
     tool_input = {
         "role": "tool",
@@ -73,4 +77,7 @@ TOOL_ATTRIBUTES = {
     "gen_ai.tool.output": tool_gen_ai_tool_output,  # TLS required
     "cozeloop.input": tool_gen_ai_tool_input,  # CozeLoop required
     "cozeloop.output": tool_gen_ai_tool_output,  # CozeLoop required
+    "gen_ai.span.kind": tool_gen_ai_span_kind,  # apmplus required
+    "gen_ai.input": tool_gen_ai_tool_input,  # apmplus required
+    "gen_ai.output": tool_gen_ai_tool_output,  # apmplus required
 }

veadk/tracing/telemetry/exporters/apmplus_exporter.py

@@ -17,8 +17,10 @@ from dataclasses import dataclass
 from typing import Any
 
 from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events import Event
 from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
+from google.adk.tools import BaseTool
 from opentelemetry import metrics, trace
 from opentelemetry import metrics as metrics_api
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
@@ -124,6 +126,12 @@ class Meters:
         "gen_ai.chat_completions.streaming_time_per_output_token"
     )
 
+    # apmplus metrics
+    # span duration
+    APMPLUS_SPAN_LATENCY = "apmplus_span_latency"
+    # tool token usage
+    APMPLUS_TOOL_TOKEN_USAGE = "apmplus_tool_token_usage"
+
 
 class MeterUploader:
     def __init__(
@@ -195,7 +203,21 @@ class MeterUploader:
             explicit_bucket_boundaries_advisory=_GEN_AI_SERVER_TIME_PER_OUTPUT_TOKEN_BUCKETS,
         )
 
-    def record(
+        # apmplus metrics for veadk dashboard
+        self.apmplus_span_latency = self.meter.create_histogram(
+            name=Meters.APMPLUS_SPAN_LATENCY,
+            description="Latency of span",
+            unit="s",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS,
+        )
+        self.apmplus_tool_token_usage = self.meter.create_histogram(
+            name=Meters.APMPLUS_TOOL_TOKEN_USAGE,
+            description="Token consumption of APMPlus tool token",
+            unit="count",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS,
+        )
+
+    def record_call_llm(
         self,
         invocation_context: InvocationContext,
         event_id: str,
@@ -205,7 +227,8 @@ class MeterUploader:
         attributes = {
             "gen_ai_system": "volcengine",
             "gen_ai_response_model": llm_request.model,
-            "gen_ai_operation_name": "chat_completions",
+            "gen_ai_operation_name": "chat",
+            "gen_ai_operation_type": "llm",
             "stream": "false",
             "server_address": "api.volcengine.com",
         }  # required by Volcengine APMPlus
@@ -267,6 +290,63 @@ class MeterUploader:
             #         time_per_output_token, attributes=attributes
             #     )
 
+            # add span name attribute
+            span = trace.get_current_span()
+            if not span:
+                return
+
+            # record span latency
+            if hasattr(span, "start_time") and self.apmplus_span_latency:
+                # span 耗时
+                duration = (time.time_ns() - span.start_time) / 1e9  # type: ignore
+                self.apmplus_span_latency.record(duration, attributes=attributes)
+
+    def record_tool_call(
+        self,
+        tool: BaseTool,
+        args: dict[str, Any],
+        function_response_event: Event,
+    ):
+        logger.debug(f"Record tool call work in progress. Tool: {tool.name}")
+        span = trace.get_current_span()
+        if not span:
+            return
+        operation_type = "tool"
+        operation_name = tool.name
+        operation_backend = ""
+        if tool.custom_metadata:
+            operation_backend = tool.custom_metadata.get("backend", "")
+
+        attributes = {
+            "gen_ai_operation_name": operation_name,
+            "gen_ai_operation_type": operation_type,
+            "gen_ai_operation_backend": operation_backend,
+        }
+
+        if hasattr(span, "start_time") and self.apmplus_span_latency:
+            # span 耗时
+            duration = (time.time_ns() - span.start_time) / 1e9  # type: ignore
+            self.apmplus_span_latency.record(duration, attributes=attributes)
+
+        if self.apmplus_tool_token_usage and hasattr(span, "attributes"):
+            tool_input = span.attributes["gen_ai.tool.input"]
+            tool_token_usage_input = (
+                len(tool_input) / 4
+            )  # tool token 数量，使用文本长度/4
+            input_tool_token_attributes = {**attributes, "token_type": "input"}
+            self.apmplus_tool_token_usage.record(
+                tool_token_usage_input, attributes=input_tool_token_attributes
+            )
+
+            tool_output = span.attributes["gen_ai.tool.output"]
+            tool_token_usage_output = (
+                len(tool_output) / 4
+            )  # tool token 数量，使用文本长度/4
+            output_tool_token_attributes = {**attributes, "token_type": "output"}
+            self.apmplus_tool_token_usage.record(
+                tool_token_usage_output, attributes=output_tool_token_attributes
+            )
+
 
 class APMPlusExporterConfig(BaseModel):
     endpoint: str = Field(

veadk/tracing/telemetry/exporters/inmemory_exporter.py

@@ -79,14 +79,20 @@ class _InMemorySpanProcessor(export.SimpleSpanProcessor):
     def on_start(self, span, parent_context) -> None:
         if span.name.startswith("invocation"):
             span.set_attribute("gen_ai.operation.name", "chain")
+            span.set_attribute("gen_ai.span.kind", "workflow")
             span.set_attribute("gen_ai.usage.total_tokens", 0)
-
             ctx = set_value("invocation_span_instance", span, context=parent_context)
+            # suppress instrumentation for llm to avoid auto instrument from apmplus, such as openai
+            ctx = set_value(
+                "suppress_language_model_instrumentation", True, context=ctx
+            )
+
             token = attach(ctx)  # mount context on `invocation` root span in Google ADK
             setattr(span, "_invocation_token", token)  # for later detach
 
-        if span.name.startswith("agent_run"):
+        if span.name.startswith("agent_run") or span.name.startswith("invoke_agent"):
             span.set_attribute("gen_ai.operation.name", "agent")
+            span.set_attribute("gen_ai.span.kind", "agent")
 
             ctx = set_value("agent_run_span_instance", span, context=parent_context)
             token = attach(ctx)

veadk/tracing/telemetry/opentelemetry_tracer.py

@@ -21,7 +21,7 @@ from typing import Any
 from opentelemetry import trace as trace_api
 from opentelemetry.sdk import trace as trace_sdk
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace import TracerProvider, SpanLimits
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from typing_extensions import override
@@ -79,7 +79,13 @@ class OpentelemetryTracer(BaseModel, BaseTracer):
 
     def _init_global_tracer_provider(self) -> None:
         # set provider anyway, then get global provider
-        trace_api.set_tracer_provider(trace_sdk.TracerProvider())
+        trace_api.set_tracer_provider(
+            trace_sdk.TracerProvider(
+                span_limits=SpanLimits(
+                    max_attributes=4096,
+                )
+            )
+        )
         global_tracer_provider: TracerProvider = trace_api.get_tracer_provider()  # type: ignore
 
         span_processors = global_tracer_provider._active_span_processor._span_processors

veadk/tracing/telemetry/telemetry.py

@@ -30,11 +30,14 @@ from veadk.tracing.telemetry.attributes.extractors.types import (
     ToolAttributesParams,
 )
 from veadk.utils.logger import get_logger
+from veadk.utils.misc import safe_json_serialize
 
 logger = get_logger(__name__)
 
+meter_uploader = None
 
-def _upload_metrics(
+
+def _upload_call_llm_metrics(
     invocation_context: InvocationContext,
     event_id: str,
     llm_request: LlmRequest,
@@ -47,11 +50,27 @@ def _upload_metrics(
         for tracer in tracers:
             for exporter in getattr(tracer, "exporters", []):
                 if getattr(exporter, "meter_uploader", None):
-                    exporter.meter_uploader.record(
+                    global meter_uploader
+                    meter_uploader = exporter.meter_uploader
+                    exporter.meter_uploader.record_call_llm(
                         invocation_context, event_id, llm_request, llm_response
                     )
 
 
+def _upload_tool_call_metrics(
+    tool: BaseTool,
+    args: dict[str, Any],
+    function_response_event: Event,
+):
+    global meter_uploader
+    if meter_uploader:
+        meter_uploader.record_tool_call(tool, args, function_response_event)
+    else:
+        logger.warning(
+            "Meter uploader is not initialized yet. Skip recording tool call metrics."
+        )
+
+
 def _set_agent_input_attribute(
     span: Span, invocation_context: InvocationContext
 ) -> None:
@@ -73,6 +92,11 @@ def _set_agent_input_attribute(
 
     user_content = invocation_context.user_content
     if user_content and user_content.parts:
+        # set gen_ai.input attribute required by APMPlus
+        span.set_attribute(
+            "gen_ai.input",
+            safe_json_serialize(user_content.model_dump(exclude_none=True)),
+        )
         span.add_event(
             "gen_ai.user.message",
             {
@@ -110,6 +134,11 @@ def _set_agent_input_attribute(
 def _set_agent_output_attribute(span: Span, llm_response: LlmResponse) -> None:
     content = llm_response.content
     if content and content.parts:
+        # set gen_ai.output attribute required by APMPlus
+        span.set_attribute(
+            "gen_ai.output", safe_json_serialize(content.model_dump(exclude_none=True))
+        )
+
         for idx, part in enumerate(content.parts):
             if part.text:
                 span.add_event(
@@ -155,10 +184,15 @@ def set_common_attributes_on_model_span(
                 current_step_token_usage + int(prev_total_token_usage)  # type: ignore
             )  # we can ignore this warning, cause we manually set the attribute to int before
             invocation_span.set_attribute(
-                "gen_ai.usage.total_tokens", accumulated_total_token_usage
+                # record input/output token usage?
+                "gen_ai.usage.total_tokens",
+                accumulated_total_token_usage,
             )
 
-        if agent_run_span and agent_run_span.name.startswith("agent_run"):
+        if agent_run_span and (
+            agent_run_span.name.startswith("agent_run")
+            or agent_run_span.name.startswith("invoke_agent")
+        ):
             _set_agent_input_attribute(agent_run_span, invocation_context)
             _set_agent_output_attribute(agent_run_span, llm_response)
             for attr_name, attr_extractor in common_attributes.items():
@@ -203,6 +237,8 @@ def trace_tool_call(
         response: ExtractorResponse = attr_extractor(params)
         ExtractorResponse.update_span(span, attr_name, response)
 
+    _upload_tool_call_metrics(tool, args, function_response_event)
+
 
 def trace_call_llm(
     invocation_context: InvocationContext,
@@ -252,7 +288,7 @@ def trace_call_llm(
         response: ExtractorResponse = attr_extractor(params)
         ExtractorResponse.update_span(span, attr_name, response)
 
-    _upload_metrics(invocation_context, event_id, llm_request, llm_response)
+    _upload_call_llm_metrics(invocation_context, event_id, llm_request, llm_response)
 
 
 # Do not modify this function

veadk/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = "0.2.8"
+VERSION = "0.2.10"

{veadk_python-0.2.8.dist-info → veadk_python-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.8
+Version: 0.2.10
 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
@@ -218,9 +218,9 @@ Requires-Dist: opentelemetry-exporter-otlp>=1.35.0
 Requires-Dist: opentelemetry-instrumentation-logging>=0.56b0
 Requires-Dist: wrapt>=1.17.2
 Requires-Dist: openai<1.100
-Requires-Dist: volcengine-python-sdk>=4.0.3
+Requires-Dist: volcengine-python-sdk>=4.0.18
 Requires-Dist: volcengine>=1.0.193
-Requires-Dist: agent-pilot-sdk>=0.0.9
+Requires-Dist: agent-pilot-sdk>=0.1.2
 Requires-Dist: fastmcp>=2.11.3
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: omegaconf>=2.3.0
@@ -235,12 +235,12 @@ Provides-Extra: extensions
 Requires-Dist: redis>=5.0; extra == "extensions"
 Requires-Dist: tos>=2.8.4; extra == "extensions"
 Requires-Dist: llama-index-vector-stores-redis>=0.6.1; extra == "extensions"
-Requires-Dist: mcp-server-vikingdb-memory; extra == "extensions"
 Provides-Extra: database
 Requires-Dist: redis>=5.0; extra == "database"
 Requires-Dist: pymysql>=1.1.1; extra == "database"
 Requires-Dist: volcengine>=1.0.193; extra == "database"
 Requires-Dist: tos>=2.8.4; extra == "database"
+Requires-Dist: mem0ai==0.1.118; extra == "database"
 Provides-Extra: eval
 Requires-Dist: prometheus-client>=0.22.1; extra == "eval"
 Requires-Dist: deepeval>=3.2.6; extra == "eval"
@@ -270,6 +270,17 @@ A [tutorial](https://github.com/volcengine/veadk-python/blob/main/veadk_tutorial
 
 ## Installation
 
+### From PyPI
+
+```python
+pip install veadk-python
+
+# install extensions
+pip install veadk-python[extensions]
+```
+
+### Build from source
+
 We use `uv` to build this project ([how-to-install-uv](https://docs.astral.sh/uv/getting-started/installation/)).
 
 ```bash