haystack-enterprise-sdk 0.1.0__tar.gz → 0.2.0__tar.gz

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/PKG-INFO

@@ -1,13 +1,16 @@
 Metadata-Version: 2.4
 Name: haystack-enterprise-sdk
-Version: 0.1.0
-Summary: Haystack Enterprise SDK
-Keywords: 
+Version: 0.2.0
+Summary: Python SDK and CLI for the Haystack Enterprise Platform
+Keywords: agents,deepset,haystack,llm,pipelines,rag,sdk
 Author: deepset.ai
 Author-email: deepset.ai <malte.pietsch@deepset.ai>
 License-Expression: Apache-2.0
 License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -15,6 +18,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
 Requires-Dist: structlog>=24.0.0
 Requires-Dist: httpx>=0.27.2
 Requires-Dist: python-dotenv>=1.0.1
@@ -53,14 +58,30 @@ Python SDK and CLI for the Haystack Enterprise Platform.
 
 ## Installation
 
-Not published to a package registry yet — install directly from this repository with [uv](https://docs.astral.sh/uv/):
-
 ```bash
 # Install as a CLI tool
-uv tool install git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
+uv tool install haystack-enterprise-sdk
 
 # Or add it as a dependency of your project
-uv add git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
+uv add haystack-enterprise-sdk
+
+# pip works too
+pip install haystack-enterprise-sdk
+```
+
+`deploy`, `validate`, and `run` load your pipeline in a subprocess using your project's own interpreter
+(an auto-detected venv, or `--python`), so the CLI environment does not need Haystack. Install the
+`deploy` extra only when the CLI environment doubles as the pipeline environment — that is, when there
+is no separate project venv to detect:
+
+```bash
+uv tool install "haystack-enterprise-sdk[deploy]"
+```
+
+To install unreleased changes from `main`:
+
+```bash
+uv tool install git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
 ```
 
 ## Usage
@@ -124,14 +145,14 @@ A deployed service is served over an OpenAI-compatible chat-completions endpoint
 once the service is running:
 
 ```bash
-curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/<deployment-id>/chat/completions \
+curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/v1/chat/completions \
   -H "Authorization: Bearer $API_KEY" \
   -H "Content-Type: application/json" \
-  -d '{"model": "<workspace>/<service-name>", "messages": [{"role": "user", "content": "Hello"}]}'
+  -d '{"model": "<workspace>/<deployment-id>", "messages": [{"role": "user", "content": "Hello"}]}'
 ```
 
 The response is a server-sent-event stream of `chat.completion.chunk` objects. Any OpenAI client works —
-point its `base_url` at everything up to and including `/deployments/<deployment-id>`.
+point its `base_url` at everything up to and including `/deployments/v1`.
 
 Pass `--verbose` to any command for INFO/DEBUG logs, and `<command> --help` for its arguments.
 

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/README.md

@@ -13,14 +13,30 @@ Python SDK and CLI for the Haystack Enterprise Platform.
 
 ## Installation
 
-Not published to a package registry yet — install directly from this repository with [uv](https://docs.astral.sh/uv/):
-
 ```bash
 # Install as a CLI tool
-uv tool install git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
+uv tool install haystack-enterprise-sdk
 
 # Or add it as a dependency of your project
-uv add git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
+uv add haystack-enterprise-sdk
+
+# pip works too
+pip install haystack-enterprise-sdk
+```
+
+`deploy`, `validate`, and `run` load your pipeline in a subprocess using your project's own interpreter
+(an auto-detected venv, or `--python`), so the CLI environment does not need Haystack. Install the
+`deploy` extra only when the CLI environment doubles as the pipeline environment — that is, when there
+is no separate project venv to detect:
+
+```bash
+uv tool install "haystack-enterprise-sdk[deploy]"
+```
+
+To install unreleased changes from `main`:
+
+```bash
+uv tool install git+https://github.com/deepset-ai/haystack-enterprise-sdk.git
 ```
 
 ## Usage
@@ -84,14 +100,14 @@ A deployed service is served over an OpenAI-compatible chat-completions endpoint
 once the service is running:
 
 ```bash
-curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/<deployment-id>/chat/completions \
+curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/v1/chat/completions \
   -H "Authorization: Bearer $API_KEY" \
   -H "Content-Type: application/json" \
-  -d '{"model": "<workspace>/<service-name>", "messages": [{"role": "user", "content": "Hello"}]}'
+  -d '{"model": "<workspace>/<deployment-id>", "messages": [{"role": "user", "content": "Hello"}]}'
 ```
 
 The response is a server-sent-event stream of `chat.completion.chunk` objects. Any OpenAI client works —
-point its `base_url` at everything up to and including `/deployments/<deployment-id>`.
+point its `base_url` at everything up to and including `/deployments/v1`.
 
 Pass `--verbose` to any command for INFO/DEBUG logs, and `<command> --help` for its arguments.
 

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/README.md

@@ -1,4 +1,4 @@
-# Software development kit for the deepset API
+# Software design
 
 This package is split into multiple layers:
 - API layer

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_api/deployments.py

@@ -10,7 +10,7 @@ list endpoint and matching client-side.
 
 import asyncio
 import enum
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Type, TypeVar
 from uuid import UUID
 
@@ -97,6 +97,10 @@ class Deployment:
     # revision, so it stays None until a revision is activated. This is the platform's own answer to
     # "is this a chat pipeline?" -- the CLI reads it rather than guessing from components or sockets.
     output_type: Optional[PipelineOutputType] = None
+    # Free-form labels, capped server-side at MAX_SERVICE_TAGS (3). Not settable at creation --
+    # the platform has no `tags` field on its create-deployment request, only the dedicated
+    # add/remove-tag endpoints below, so this always reflects a create followed by N tag calls.
+    tags: List[str] = field(default_factory=list)
 
     @classmethod
     def from_response(cls, body: Dict[str, Any]) -> "Deployment":
@@ -120,6 +124,7 @@ class Deployment:
             # The platform enum has values this SDK does not model (e.g. "unknown"), and the field is
             # absent until a revision is active, so anything unrecognized degrades to None.
             output_type=_enum_or_none(PipelineOutputType, body.get("output_type")),
+            tags=list(body.get("tags") or []),
         )
 
 
@@ -244,6 +249,15 @@ class FailedToActivateRevisionError(Exception):
     """Raised when a deployment revision could not be activated."""
 
 
+class FailedToTagDeploymentError(Exception):
+    """Raised when a tag could not be added to, or removed from, a deployment.
+
+    Covers the platform's own rejections too: a name over 50 chars or outside
+    ``[A-Za-z0-9 _-]``, a duplicate (case-insensitive), or a fourth tag past MAX_SERVICE_TAGS (3)
+    all come back as a 4xx from the tag endpoints, not just a network/auth failure.
+    """
+
+
 class FailedToValidatePipelineError(Exception):
     """Raised when the validation request itself failed (e.g. auth/5xx), not the pipeline config."""
 
@@ -453,6 +467,50 @@ class DeploymentsAPI:
         )
         return Deployment.from_response(response.json())
 
+    async def add_tag(self, workspace_name: str, deployment_id: UUID, tag_name: str) -> List[str]:
+        """Add a tag to a deployment.
+
+        :param workspace_name: Name of the workspace.
+        :param deployment_id: Deployment id.
+        :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+            Rejected as a duplicate case-insensitively, and past the third tag on one deployment.
+        :raises FailedToTagDeploymentError: If the tag could not be added.
+        :return: The deployment's full tag list after the add.
+        """
+        response = await self._haystack_enterprise_api.post(
+            workspace_name=workspace_name,
+            endpoint=f"{self._ENDPOINT}/{deployment_id}/tags",
+            json={"name": tag_name},
+        )
+        raise_for_unexpected_status(
+            response,
+            (codes.OK,),
+            FailedToTagDeploymentError,
+            f"Failed to add tag {tag_name!r} to deployment '{deployment_id}'.",
+        )
+        return list(response.json())
+
+    async def remove_tag(self, workspace_name: str, deployment_id: UUID, tag_name: str) -> List[str]:
+        """Remove a tag from a deployment. Matching is case-insensitive.
+
+        :param workspace_name: Name of the workspace.
+        :param deployment_id: Deployment id.
+        :param tag_name: Tag name to remove.
+        :raises FailedToTagDeploymentError: If the tag could not be removed (including "not found").
+        :return: The deployment's full tag list after the removal.
+        """
+        response = await self._haystack_enterprise_api.delete(
+            workspace_name=workspace_name,
+            endpoint=f"{self._ENDPOINT}/{deployment_id}/tags/{tag_name}",
+        )
+        raise_for_unexpected_status(
+            response,
+            (codes.OK,),
+            FailedToTagDeploymentError,
+            f"Failed to remove tag {tag_name!r} from deployment '{deployment_id}'.",
+        )
+        return list(response.json())
+
     async def validate_pipeline(
         self,
         workspace_name: str,

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_api/haystack_enterprise_api.py

@@ -148,11 +148,9 @@ def raise_for_unexpected_status(
 
 
 def deployment_base_url(api_url: str, workspace_name: str, deployment_id: Any) -> str:
-    """Build the base URL of a deployment's OpenAI-compatible endpoint.
+    """Build the per-deployment base URL (used for per-deployment routes like ``/chat`` and ``/chat-stream``).
 
-    The platform serves ``POST <this>/chat/completions`` for a deployment with an active revision. It is
-    keyed on the deployment id, not the service name. Returned without the ``/chat/completions`` suffix
-    because that is exactly the ``base_url`` an OpenAI client expects (it appends the path itself).
+    Returned without a trailing path segment because callers append their own route (e.g. ``/chat``).
 
     :param api_url: Base API URL, already normalized (see :func:`~haystack_enterprise_sdk._api.config.normalize_base_url`).
     :param workspace_name: Name of the workspace the deployment lives in.
@@ -162,6 +160,20 @@ def deployment_base_url(api_url: str, workspace_name: str, deployment_id: Any) -
     return f"{api_url}/{API_VERSION_PATH}/workspaces/{workspace_name}/deployments/{deployment_id}"
 
 
+def chat_completions_base_url(api_url: str, workspace_name: str) -> str:
+    """Build the workspace-scoped OpenAI-compatible chat-completions base URL.
+
+    The platform's OpenAI-compatible gateway lives at ``POST <this>/chat/completions``.
+    The ``model`` field must be ``{workspace_name}/{deployment_id}`` (UUID, not service name).
+    Returned without the ``/chat/completions`` suffix so an OpenAI client can use it as ``base_url``.
+
+    :param api_url: Base API URL, already normalized (see :func:`~haystack_enterprise_sdk._api.config.normalize_base_url`).
+    :param workspace_name: Name of the workspace.
+    :return: e.g. ``https://api.cloud.deepset.ai/api/v1/workspaces/my-ws/deployments/v1``.
+    """
+    return f"{api_url}/{API_VERSION_PATH}/workspaces/{workspace_name}/deployments/v1"
+
+
 class HaystackEnterpriseAPI:
     """Haystack Enterprise Platform API client.
 

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_service/deployment_service.py

@@ -22,6 +22,7 @@ from haystack_enterprise_sdk._api.deployments import (
     DeploymentsAPI,
     DeploymentServiceLevel,
     DeploymentStatus,
+    FailedToTagDeploymentError,
     PipelineValidationError,
     PipelineValidationResult,
 )
@@ -147,6 +148,9 @@ class CreateOptions:
     cpu_limit: Optional[str] = None
     memory_limit: Optional[str] = None
     gpu_limit_gigabyte: Optional[int] = None
+    # Applied with one add_tag call each, right after creation -- the create-deployment endpoint
+    # itself has no `tags` field. Not a sizing field: it applies to serverless services too.
+    tags: Tuple[str, ...] = ()
 
     _SIZING_FIELDS = (
         "service_level",
@@ -493,6 +497,38 @@ class DeploymentService:
             )
         return await self._deployments.get_deployment(self._workspace_name, deployment.deployment_id)
 
+    async def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create.
+
+        :param service_name: Name of the service deployment.
+        :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+        :raises ServiceNotFoundError: If no service with that name exists.
+        :raises FailedToTagDeploymentError: If the platform rejected it (limit, duplicate, bad name).
+        :return: The service's full tag list after the add.
+        """
+        deployment = await self._deployments.find_by_name(self._workspace_name, service_name)
+        if deployment is None:
+            raise ServiceNotFoundError(
+                f"No service deployment named '{service_name}' in workspace '{self._workspace_name}'."
+            )
+        return await self._deployments.add_tag(self._workspace_name, deployment.deployment_id, tag_name)
+
+    async def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name. Matching is case-insensitive.
+
+        :param service_name: Name of the service deployment.
+        :param tag_name: Tag name to remove.
+        :raises ServiceNotFoundError: If no service with that name exists.
+        :raises FailedToTagDeploymentError: If the tag could not be removed (including "not found").
+        :return: The service's full tag list after the removal.
+        """
+        deployment = await self._deployments.find_by_name(self._workspace_name, service_name)
+        if deployment is None:
+            raise ServiceNotFoundError(
+                f"No service deployment named '{service_name}' in workspace '{self._workspace_name}'."
+            )
+        return await self._deployments.remove_tag(self._workspace_name, deployment.deployment_id, tag_name)
+
     async def create_shared_prototype(
         self, service_name: str, options: Optional[ShareOptions] = None
     ) -> SharedPrototype:
@@ -538,7 +574,7 @@ class DeploymentService:
             )
         options = create_options or CreateOptions()
         logger.info("Creating service deployment.", service=service_name, mode=options.deployment_mode.value)
-        return await self._deployments.create_deployment(
+        deployment = await self._deployments.create_deployment(
             self._workspace_name,
             name=service_name,
             deployment_mode=options.deployment_mode,
@@ -550,6 +586,24 @@ class DeploymentService:
             memory_limit=options.memory_limit,
             gpu_limit_gigabyte=options.gpu_limit_gigabyte,
         )
+        for tag_name in options.tags:
+            # Sequential, not gathered: each call returns the full tag list so far, and the
+            # platform's own duplicate/limit checks are per-request -- gathering could race two
+            # adds past the 3-tag cap. There are at most 3 of these, so latency is not a concern.
+            #
+            # Caught here rather than left to propagate: the service was already created, so raising
+            # would abort a deploy that otherwise fully succeeded. `tag-add` can retry independently.
+            try:
+                deployment.tags = await self._deployments.add_tag(
+                    self._workspace_name, deployment.deployment_id, tag_name
+                )
+            except FailedToTagDeploymentError:
+                logger.warning(
+                    "Failed to add tag to newly created service; retry with 'tag-add'.",
+                    service=service_name,
+                    tag=tag_name,
+                )
+        return deployment
 
     async def _poll_until_settled(
         self,

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_service/pipeline_extract.py

@@ -33,6 +33,7 @@ import json
 import logging
 import os
 import sys
+import sysconfig
 from pathlib import Path
 from typing import Any, Optional
 
@@ -53,6 +54,21 @@ _INDEX_MARKER_SUFFIXES = ("DocumentWriter",)
 # Path components that mark an installed package (even when the venv lives inside the project dir).
 _INSTALLED_PACKAGE_DIRS = {"site-packages", "dist-packages"}
 
+# Namespaces the platform runtime provides itself. Never inline these, even when they resolve to a
+# source checkout instead of site-packages (an editable ``haystack-ai`` install, for example).
+_PLATFORM_NAMESPACES = ("haystack", "haystack_integrations", "deepset_cloud_custom_nodes")
+
+# Directories owned by the interpreter running this extractor: its stdlib and its installed packages.
+_INTERPRETER_DIRS = frozenset(
+    Path(p).resolve()
+    for p in (
+        sysconfig.get_paths()["stdlib"],
+        sysconfig.get_paths()["platstdlib"],
+        sys.prefix,
+        sys.base_prefix,
+    )
+)
+
 
 class PipelineTransformError(Exception):
     """Raised when the pipeline cannot be loaded or transformed into deployable YAML."""
@@ -277,9 +293,20 @@ def _reject_index_pipeline(pipeline: Any) -> None:
 # Import classification
 # --------------------------------------------------------------------------- #
 def classify_module(module_name: str, project_root: Path) -> str:
-    """Classify ``module_name`` as ``'local'``, ``'external'``, or ``'stdlib'``."""
+    """Classify ``module_name`` as ``'local'``, ``'external'``, or ``'stdlib'``.
+
+    Only ``'local'`` is acted on (it means "inline this into a platform Code component"); the other two
+    are equivalent "leave it alone" answers.
+    """
     if not module_name:
         return "external"
+    top = module_name.partition(".")[0]
+    # Decided by name, not by path: these must never be inlined even when they resolve to a source
+    # checkout (a vendored stdlib module, or an editable ``haystack-ai`` install).
+    if top in sys.stdlib_module_names:
+        return "stdlib"
+    if top in _PLATFORM_NAMESPACES:
+        return "external"
     try:
         spec = importlib.util.find_spec(module_name)
     except (ImportError, ValueError, ModuleNotFoundError, AttributeError):
@@ -299,12 +326,19 @@ def _classify_origin(origin_path: Path, project_root: Path) -> str:
     virtualenv often lives *inside* the project directory (e.g. ``<project>/.venv/.../site-packages``),
     so installed packages resolve under ``project_root`` yet must be treated as external dependencies,
     not inlined as local source.
+
+    Anything that is neither installed nor owned by the interpreter is the user's own source, wherever
+    it sits on disk. ``project_root`` (the pipeline file's directory) is only a fast positive hint:
+    requiring containment in it would miss the standard ``src``-layout repo, where the pipeline lives in
+    ``pipelines/`` and its components in ``src/``.
     """
     if _INSTALLED_PACKAGE_DIRS.intersection(origin_path.parts):
         return "external"
     if _is_relative_to(origin_path, project_root):
         return "local"
-    return "stdlib"
+    if any(_is_relative_to(origin_path, d) for d in _INTERPRETER_DIRS):
+        return "stdlib"
+    return "local"
 
 
 def _is_relative_to(path: Path, root: Path) -> bool:
@@ -1599,6 +1633,17 @@ def extract_from_pipeline(pipeline: Any, project_root: Path) -> dict:
         comp_type = comp.get("type", "")
         module_name = comp_type.rpartition(".")[0]
         if classify_module(module_name, project_root) != "local":
+            if not comp_type.startswith(_PLATFORM_NAMESPACES):
+                # Can't be inlined and isn't something the platform ships. Most likely first-party code
+                # deployed from an installed copy (``pip install ./src``), which we cannot tell apart
+                # from a third-party integration - so say so rather than fail on the platform later.
+                logger.warning(
+                    "Component '%s' keeps its original type '%s': it did not resolve to local source, so "
+                    "the platform must be able to import it. If it is your own code, deploy from the "
+                    "source tree rather than from an installed copy.",
+                    comp_name,
+                    comp_type,
+                )
             continue
         logger.debug("Rewriting local component '%s' (%s) to Code", comp_name, comp_type)
         code = _build_code_block(comp_type, project_root)

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/cli.py

@@ -27,6 +27,7 @@ from haystack_enterprise_sdk._api.config import (
 from haystack_enterprise_sdk._api.deployments import (
     DeploymentMode,
     DeploymentServiceLevel,
+    FailedToTagDeploymentError,
     PipelineValidationError,
 )
 from haystack_enterprise_sdk._api.haystack_enterprise_api import HaystackEnterpriseAPIError
@@ -449,6 +450,9 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     memory: Optional[str] = None,
     gpu: Optional[int] = None,
     idle_timeout: Optional[int] = None,
+    tag: Optional[List[str]] = typer.Option(
+        None, "--tag", help="Tag to add when creating the service (repeatable; up to 3)."
+    ),
     python: Optional[str] = None,
     dry_run: bool = False,
     output: Optional[Path] = None,
@@ -492,6 +496,11 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     :param memory: Memory limit, e.g. '2Gi' (with --managed).
     :param gpu: GPU memory limit in gigabytes (with --managed).
     :param idle_timeout: Idle timeout in seconds before scale-down (with --managed).
+    :param tag: Tag to add to the service when it is created (repeatable; the platform allows at
+        most 3 per service). Only applies when the service is created -- pass --create, or omit
+        --create against a service name that does not exist yet. Rejected if the service already
+        exists, same as --managed and the sizing flags -- use `tag-add`/`tag-remove` to change
+        tags on a service after creation.
     :param python: Path to the Python interpreter used to load your pipeline (defaults to an
         auto-detected virtualenv near the target file, else the current interpreter).
     :param dry_run: Transform the pipeline and print/write the resulting YAML without deploying. No
@@ -524,6 +533,9 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     Create a managed service with explicit sizing (activates and waits for the rollout):
     `haystack-enterprise deploy pipeline.py my-service --managed --service-level PRODUCTION --cpu 2`
 
+    Create a service tagged for a team and a hackathon, up to 3 tags:
+    `haystack-enterprise deploy pipeline.py my-service --create --tag team-success --tag hackathon`
+
     Describe the revision instead of using the auto-generated comment:
     `haystack-enterprise deploy pipeline.py my-service -m "Bump embedder model to bge-large"`
 
@@ -575,8 +587,8 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     if create is False and existing is None:
         typer.echo(f"No service named '{service_name}' in workspace '{workspace_name}'. Drop --no-create to create it.")
         raise typer.Exit(1)
-    if existing is not None and (managed or given_sizing):
-        creation_flags = (["--managed"] if managed else []) + given_sizing
+    if existing is not None and (managed or given_sizing or tag):
+        creation_flags = (["--managed"] if managed else []) + given_sizing + (["--tag"] if tag else [])
         applies = "only applies" if len(creation_flags) == 1 else "only apply"
         typer.echo(
             f"Service '{service_name}' already exists; {', '.join(creation_flags)} {applies} when a "
@@ -596,9 +608,10 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
             cpu_limit=cpu,
             memory_limit=memory,
             gpu_limit_gigabyte=gpu,
+            tags=tuple(tag or ()),
         )
     else:
-        create_options = CreateOptions(deployment_mode=DeploymentMode.SERVERLESS)
+        create_options = CreateOptions(deployment_mode=DeploymentMode.SERVERLESS, tags=tuple(tag or ()))
 
     activate = not skip_activation
 
@@ -1152,8 +1165,8 @@ def _echo_endpoint(client: DeploymentClient, service_name: str, result: DeployRe
     if not result.is_deployed:
         return
 
-    base_url = client.deployment_base_url(result.deployment.deployment_id)
-    model = f"{client.workspace_name}/{service_name}"
+    base_url = client.chat_completions_base_url()
+    model = f"{client.workspace_name}/{result.deployment.deployment_id}"
     typer.echo(f"\nChat completions endpoint (OpenAI-compatible):\n  POST {base_url}/chat/completions")
     typer.echo(
         f"\n  curl -N {base_url}/chat/completions \\\n"
@@ -1649,12 +1662,70 @@ def service_status(
                 "pending_revision_id": (
                     str(deployment.pending_revision_id) if deployment.pending_revision_id else None
                 ),
+                "tags": deployment.tags,
             },
             indent=4,
         )
     )
 
 
+@cli_app.command()
+def tag_add(
+    service_name: str,
+    tag_name: str,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    workspace_name: str = DEFAULT_WORKSPACE_NAME,
+) -> None:
+    """Add a tag to a service deployment, independent of deploy/create.
+
+    :param service_name: Name of the service deployment.
+    :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+        Rejected as a duplicate case-insensitively, and past the third tag on one service.
+    :param api_key: deepset API key to use for authentication.
+    :param api_url: API URL to use for authentication.
+    :param workspace_name: Workspace of the service. Uses the workspace from the .ENV file by default.
+
+    Example:
+    `haystack-enterprise tag-add my-service hackathon`
+    """
+    client = DeploymentClient(api_key=api_key, api_url=api_url, workspace_name=workspace_name)
+    try:
+        tags = client.add_tag(service_name, tag_name)
+    except (ServiceNotFoundError, FailedToTagDeploymentError) as err:
+        typer.echo(str(err))
+        raise typer.Exit(1)  # noqa: B904
+    typer.echo(f"Tags on '{service_name}': {', '.join(tags) or '(none)'}")
+
+
+@cli_app.command()
+def tag_remove(
+    service_name: str,
+    tag_name: str,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    workspace_name: str = DEFAULT_WORKSPACE_NAME,
+) -> None:
+    """Remove a tag from a service deployment. Matching is case-insensitive.
+
+    :param service_name: Name of the service deployment.
+    :param tag_name: Tag name to remove.
+    :param api_key: deepset API key to use for authentication.
+    :param api_url: API URL to use for authentication.
+    :param workspace_name: Workspace of the service. Uses the workspace from the .ENV file by default.
+
+    Example:
+    `haystack-enterprise tag-remove my-service hackathon`
+    """
+    client = DeploymentClient(api_key=api_key, api_url=api_url, workspace_name=workspace_name)
+    try:
+        tags = client.remove_tag(service_name, tag_name)
+    except (ServiceNotFoundError, FailedToTagDeploymentError) as err:
+        typer.echo(str(err))
+        raise typer.Exit(1)  # noqa: B904
+    typer.echo(f"Tags on '{service_name}': {', '.join(tags) or '(none)'}")
+
+
 def version_callback(value: bool) -> None:
     """Show the SDK version and exit.
 

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/workflows/async_client/deployment_client.py

@@ -19,6 +19,7 @@ from haystack_enterprise_sdk._api.deployments import (
 )
 from haystack_enterprise_sdk._api.haystack_enterprise_api import (
     HaystackEnterpriseAPI,
+    chat_completions_base_url,
     deployment_base_url,
 )
 from haystack_enterprise_sdk._api.pipeline_run import DEFAULT_RUN_RETRIES, OnRetry
@@ -76,16 +77,23 @@ class AsyncDeploymentClient:
         return self._workspace_name
 
     def deployment_base_url(self, deployment_id: Any) -> str:
-        """The OpenAI-compatible base URL of a deployment in this client's workspace.
-
-        Append ``/chat/completions`` to call it directly, or hand it to an OpenAI client as ``base_url``.
-        Only usable once the deployment has an active revision.
+        """The per-deployment base URL (for per-deployment routes like ``/chat`` and ``/chat-stream``).
 
         :param deployment_id: Id of the deployment (e.g. ``DeployResult.deployment.deployment_id``).
         :return: The deployment's base URL.
         """
         return deployment_base_url(self._api_config.api_url, self._workspace_name, deployment_id)
 
+    def chat_completions_base_url(self) -> str:
+        """The workspace-scoped OpenAI-compatible base URL for chat completions.
+
+        Use ``POST <this>/chat/completions`` with ``model`` set to ``{workspace}/{deployment_id}`` (UUID).
+        Pass this as ``base_url`` to an OpenAI client.
+
+        :return: e.g. ``https://api.cloud.deepset.ai/api/v1/workspaces/my-ws/deployments/v1``.
+        """
+        return chat_completions_base_url(self._api_config.api_url, self._workspace_name)
+
     @asynccontextmanager
     async def _service(self) -> AsyncIterator[DeploymentService]:
         """Yield a :class:`DeploymentService` backed by a managed API client."""
@@ -210,6 +218,20 @@ class AsyncDeploymentClient:
         async with self._service() as service:
             return await service.get_service_status(service_name)
 
+    async def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create. See
+        :meth:`haystack_enterprise_sdk._service.deployment_service.DeploymentService.add_tag`.
+        """
+        async with self._service() as service:
+            return await service.add_tag(service_name, tag_name)
+
+    async def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name. See
+        :meth:`haystack_enterprise_sdk._service.deployment_service.DeploymentService.remove_tag`.
+        """
+        async with self._service() as service:
+            return await service.remove_tag(service_name, tag_name)
+
     async def create_shared_prototype(
         self, service_name: str, options: Optional[ShareOptions] = None
     ) -> SharedPrototype:

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/workflows/sync_client/deployment_client.py

@@ -183,6 +183,14 @@ class DeploymentClient:  # pylint: disable=too-few-public-methods
         """Return the current deployment (with live runtime status) for ``service_name``."""
         return _run(self._async_client.get_service_status(service_name))
 
+    def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create, synchronously."""
+        return _run(self._async_client.add_tag(service_name, tag_name))
+
+    def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name synchronously."""
+        return _run(self._async_client.remove_tag(service_name, tag_name))
+
     def create_shared_prototype(self, service_name: str, options: Optional[ShareOptions] = None) -> SharedPrototype:
         """Create a shared prototype (a shareable chat UI link) for a deployed service synchronously."""
         return _run(self._async_client.create_shared_prototype(service_name, options))
@@ -193,5 +201,9 @@ class DeploymentClient:  # pylint: disable=too-few-public-methods
         return self._async_client.workspace_name
 
     def deployment_base_url(self, deployment_id: Any) -> str:
-        """The OpenAI-compatible base URL of a deployment. See :meth:`AsyncDeploymentClient.deployment_base_url`."""
+        """The per-deployment base URL. See :meth:`AsyncDeploymentClient.deployment_base_url`."""
         return self._async_client.deployment_base_url(deployment_id)
+
+    def chat_completions_base_url(self) -> str:
+        """The workspace-scoped chat-completions base URL. See :meth:`AsyncDeploymentClient.chat_completions_base_url`."""
+        return self._async_client.chat_completions_base_url()

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/pyproject.toml

@@ -1,18 +1,29 @@
 [build-system]
-requires = ["uv_build>=0.9.13,<0.12.0"]
+requires = ["uv_build>=0.9.13,<0.13.0"]
 build-backend = "uv_build"
 
 [project]
 name = "haystack-enterprise-sdk"
-version = "0.1.0"
-description = "Haystack Enterprise SDK"
+version = "0.2.0"
+description = "Python SDK and CLI for the Haystack Enterprise Platform"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
-keywords = []
+keywords = [
+    "agents",
+    "deepset",
+    "haystack",
+    "llm",
+    "pipelines",
+    "rag",
+    "sdk",
+]
 classifiers = [
     "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
@@ -20,6 +31,8 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
 ]
 dependencies = [
     "structlog>=24.0.0",
@@ -66,7 +79,7 @@ code-quality = [
     "ruff==0.15.12",
     "mypy==1.19.1",
     "pre-commit==4.3.0",
-    "types-aiofiles==25.1.0.20251011",
+    "types-aiofiles==25.1.0.20260518",
     "types-tabulate==0.9.0.20241207",
 ]
 

{haystack_enterprise_sdk-0.1.0 → haystack_enterprise_sdk-0.2.0}/pyproject.toml.orig

@@ -1,19 +1,30 @@
 [build-system]
-requires = ["uv_build>=0.9.13,<0.12.0"]
+requires = ["uv_build>=0.9.13,<0.13.0"]
 build-backend = "uv_build"
 
 [project]
 name = "haystack-enterprise-sdk"
-version = "0.1.0"
-description = 'Haystack Enterprise SDK'
+version = "0.2.0"
+description = "Python SDK and CLI for the Haystack Enterprise Platform"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
-keywords = []
+keywords = [
+  "agents",
+  "deepset",
+  "haystack",
+  "llm",
+  "pipelines",
+  "rag",
+  "sdk",
+]
 authors = [{ name = "deepset.ai", email = "malte.pietsch@deepset.ai" }]
 classifiers = [
   "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.10",
@@ -21,6 +32,8 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Typing :: Typed",
 ]
 dependencies = [
   "structlog>=24.0.0",
@@ -70,7 +83,7 @@ code-quality = [
   "ruff==0.15.12",
   "mypy==1.19.1",
   "pre-commit==4.3.0",
-  "types-aiofiles==25.1.0.20251011",
+  "types-aiofiles==25.1.0.20260518",
   "types-tabulate==0.9.0.20241207",
 ]