semantic-kernel 1.8.3__zip

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/google/vertex_ai/services/vertex_ai_text_embedding.py

@@ -0,0 +1,109 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import sys
+from typing import Any
+
+import vertexai
+from numpy import array, ndarray
+from pydantic import ValidationError
+from vertexai.language_models import TextEmbedding, TextEmbeddingModel
+
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import EmbeddingGeneratorBase
+from semantic_kernel.connectors.ai.google.vertex_ai.services.vertex_ai_base import VertexAIBase
+from semantic_kernel.connectors.ai.google.vertex_ai.vertex_ai_prompt_execution_settings import (
+    VertexAIEmbeddingPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.google.vertex_ai.vertex_ai_settings import VertexAISettings
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.exceptions.service_exceptions import ServiceInitializationError
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+
+class VertexAITextEmbedding(VertexAIBase, EmbeddingGeneratorBase):
+    """Vertex AI Text Embedding Service."""
+
+    def __init__(
+        self,
+        project_id: str | None = None,
+        region: str | None = None,
+        embedding_model_id: str | None = None,
+        service_id: str | None = None,
+        env_file_path: str | None = None,
+        env_file_encoding: str | None = None,
+    ) -> None:
+        """Initialize the Google Vertex AI Chat Completion Service.
+
+        If no arguments are provided, the service will attempt to load the settings from the environment.
+        The following environment variables are used:
+        - VERTEX_AI_EMBEDDING_MODEL_ID
+        - VERTEX_AI_PROJECT_ID
+
+        Args:
+            project_id (str): The Google Cloud project ID.
+            region (str): The Google Cloud region.
+            embedding_model_id (str): The Gemini model ID.
+            service_id (str): The Vertex AI service ID.
+            env_file_path (str): The path to the environment file.
+            env_file_encoding (str): The encoding of the environment file.
+        """
+        try:
+            vertex_ai_settings = VertexAISettings.create(
+                project_id=project_id,
+                region=region,
+                embedding_model_id=embedding_model_id,
+                env_file_path=env_file_path,
+                env_file_encoding=env_file_encoding,
+            )
+        except ValidationError as e:
+            raise ServiceInitializationError(f"Failed to validate Vertex AI settings: {e}") from e
+        if not vertex_ai_settings.embedding_model_id:
+            raise ServiceInitializationError("The Vertex AI embedding model ID is required.")
+
+        super().__init__(
+            ai_model_id=vertex_ai_settings.embedding_model_id,
+            service_id=service_id or vertex_ai_settings.embedding_model_id,
+            service_settings=vertex_ai_settings,
+        )
+
+    @override
+    async def generate_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> ndarray:
+        raw_embeddings = await self.generate_raw_embeddings(texts, settings, **kwargs)
+        return array(raw_embeddings)
+
+    @override
+    async def generate_raw_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        if not settings:
+            settings = VertexAIEmbeddingPromptExecutionSettings()
+        else:
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, VertexAIEmbeddingPromptExecutionSettings)  # nosec
+
+        vertexai.init(project=self.service_settings.project_id, location=self.service_settings.region)
+        model = TextEmbeddingModel.from_pretrained(self.service_settings.embedding_model_id)
+        response: list[TextEmbedding] = await model.get_embeddings_async(
+            texts,
+            **settings.prepare_settings_dict(),
+        )
+
+        return [text_embedding.values for text_embedding in response]
+
+    @override
+    def get_prompt_execution_settings_class(
+        self,
+    ) -> type["PromptExecutionSettings"]:
+        """Get the request settings class."""
+        return VertexAIEmbeddingPromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/google/vertex_ai/vertex_ai_prompt_execution_settings.py

@@ -0,0 +1,67 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import sys
+from typing import Any, Literal
+
+from pydantic import Field
+from vertexai.generative_models import Tool, ToolConfig
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+
+class VertexAIPromptExecutionSettings(PromptExecutionSettings):
+    """Vertex AI Prompt Execution Settings."""
+
+    stop_sequences: list[str] | None = Field(None, max_length=5)
+    response_mime_type: Literal["text/plain", "application/json"] | None = None
+    response_schema: Any | None = None
+    candidate_count: int | None = Field(None, ge=1)
+    max_output_tokens: int | None = Field(None, ge=1)
+    temperature: float | None = Field(None, ge=0.0, le=2.0)
+    top_p: float | None = None
+    top_k: int | None = None
+
+
+class VertexAITextPromptExecutionSettings(VertexAIPromptExecutionSettings):
+    """Vertex AI Text Prompt Execution Settings."""
+
+    pass
+
+
+class VertexAIChatPromptExecutionSettings(VertexAIPromptExecutionSettings):
+    """Vertex AI Chat Prompt Execution Settings."""
+
+    tools: list[Tool] | None = Field(
+        None,
+        max_length=64,
+        description="Do not set this manually. It is set by the service based on the function choice configuration.",
+    )
+    tool_config: ToolConfig | None = Field(
+        None,
+        description="Do not set this manually. It is set by the service based on the function choice configuration.",
+    )
+
+    @override
+    def prepare_settings_dict(self, **kwargs) -> dict[str, Any]:
+        """Prepare the settings as a dictionary for sending to the AI service.
+
+        This method removes the tools and tool_config keys from the settings dictionary, as
+        the Vertex AI service mandates these two settings to be sent as separate parameters.
+        """
+        settings_dict = super().prepare_settings_dict(**kwargs)
+        settings_dict.pop("tools", None)
+        settings_dict.pop("tool_config", None)
+
+        return settings_dict
+
+
+class VertexAIEmbeddingPromptExecutionSettings(PromptExecutionSettings):
+    """Google AI Embedding Prompt Execution Settings."""
+
+    auto_truncate: bool | None = None
+    output_dimensionality: int | None = None

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/google/vertex_ai/vertex_ai_settings.py

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import ClassVar
+
+from semantic_kernel.kernel_pydantic import KernelBaseSettings
+
+
+class VertexAISettings(KernelBaseSettings):
+    """Vertex AI settings.
+
+    The settings are first loaded from environment variables with
+    the prefix 'VERTEX_AI_'.
+    If the environment variables are not found, the settings can
+    be loaded from a .env file with the encoding 'utf-8'.
+    If the settings are not found in the .env file, the settings
+    are ignored; however, validation will fail alerting that the
+    settings are missing.
+
+    Required settings for prefix 'VERTEX_AI_' are:
+    - gemini_model_id: str - The Gemini model ID for the Vertex AI service, i.e. gemini-1.5-pro
+                This value can be found in the Vertex AI service deployment.
+                (Env var VERTEX_AI_GEMINI_MODEL_ID)
+    - embedding_model_id: str - The embedding model ID for the Vertex AI service, i.e. text-embedding-004
+                This value can be found in the Vertex AI service deployment.
+                (Env var VERTEX_AI_EMBEDDING_MODEL_ID)
+    - project_id: str - The Google Cloud project ID.
+                (Env var VERTEX_AI_PROJECT_ID)
+    - region: str - The Google Cloud region.
+                (Env var VERTEX_AI_REGION)
+    """
+
+    env_prefix: ClassVar[str] = "VERTEX_AI_"
+
+    gemini_model_id: str | None = None
+    embedding_model_id: str | None = None
+    project_id: str
+    region: str | None = None

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/hugging_face/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.ai.hugging_face.hf_prompt_execution_settings import (
+    HuggingFacePromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.hugging_face.services.hf_text_completion import (
+    HuggingFaceTextCompletion,
+)
+from semantic_kernel.connectors.ai.hugging_face.services.hf_text_embedding import (
+    HuggingFaceTextEmbedding,
+)
+
+__all__ = [
+    "HuggingFacePromptExecutionSettings",
+    "HuggingFaceTextCompletion",
+    "HuggingFaceTextEmbedding",
+]

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/hugging_face/hf_prompt_execution_settings.py

@@ -0,0 +1,42 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Any
+
+from transformers import GenerationConfig
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+
+class HuggingFacePromptExecutionSettings(PromptExecutionSettings):
+    """Hugging Face prompt execution settings."""
+
+    do_sample: bool = True
+    max_new_tokens: int = 256
+    num_return_sequences: int = 1
+    stop_sequences: Any = None
+    pad_token_id: int = 50256
+    eos_token_id: int = 50256
+    temperature: float = 1.0
+    top_p: float = 1.0
+
+    def get_generation_config(self) -> GenerationConfig:
+        """Get the generation config."""
+        return GenerationConfig(
+            **self.model_dump(
+                include={"max_new_tokens", "pad_token_id", "eos_token_id", "temperature", "top_p"},
+                exclude_unset=False,
+                exclude_none=True,
+                by_alias=True,
+            )
+        )
+
+    def prepare_settings_dict(self, **kwargs) -> dict[str, Any]:
+        """Prepare the settings dictionary."""
+        gen_config = self.get_generation_config()
+        settings = {
+            "generation_config": gen_config,
+            "num_return_sequences": self.num_return_sequences,
+            "do_sample": self.do_sample,
+        }
+        settings.update(kwargs)
+        return settings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/hugging_face/services/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Microsoft. All rights reserved.

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/hugging_face/services/hf_text_completion.py

@@ -0,0 +1,162 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from collections.abc import AsyncGenerator
+from threading import Thread
+from typing import Any, Literal
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+import torch
+from transformers import AutoTokenizer, TextIteratorStreamer, pipeline
+
+from semantic_kernel.connectors.ai.hugging_face.hf_prompt_execution_settings import HuggingFacePromptExecutionSettings
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.connectors.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.contents.streaming_text_content import StreamingTextContent
+from semantic_kernel.contents.text_content import TextContent
+from semantic_kernel.exceptions import ServiceInvalidExecutionSettingsError, ServiceResponseException
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class HuggingFaceTextCompletion(TextCompletionClientBase):
+    """Hugging Face text completion service."""
+
+    task: Literal["summarization", "text-generation", "text2text-generation"]
+    device: str
+    generator: Any
+
+    def __init__(
+        self,
+        ai_model_id: str,
+        task: str | None = "text2text-generation",
+        device: int = -1,
+        service_id: str | None = None,
+        model_kwargs: dict[str, Any] | None = None,
+        pipeline_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """Initializes a new instance of the HuggingFaceTextCompletion class.
+
+        Args:
+            ai_model_id (str): Hugging Face model card string, see
+                https://huggingface.co/models
+            device (int): Device to run the model on, defaults to CPU, 0+ for GPU,
+                -- None if using device_map instead. (If both device and device_map
+                are specified, device overrides device_map. If unintended,
+                it can lead to unexpected behavior.) (optional)
+            service_id (str): Service ID for the AI service. (optional)
+            task (str): Model completion task type, options are:
+                - summarization: takes a long text and returns a shorter summary.
+                - text-generation: takes incomplete text and returns a set of completion candidates.
+                - text2text-generation (default): takes an input prompt and returns a completion.
+                text2text-generation is the default as it behaves more like GPT-3+. (optional)
+            model_kwargs (dict[str, Any]): Additional dictionary of keyword arguments
+                passed along to the model's `from_pretrained(..., **model_kwargs)` function. (optional)
+            pipeline_kwargs (dict[str, Any]): Additional keyword arguments passed along
+                to the specific pipeline init (see the documentation for the corresponding pipeline class
+                for possible values). (optional)
+
+        Note that this model will be downloaded from the Hugging Face model hub.
+        """
+        generator = pipeline(
+            task=task,
+            model=ai_model_id,
+            device=device,
+            model_kwargs=model_kwargs,
+            **pipeline_kwargs or {},
+        )
+        resolved_device = f"cuda:{device}" if device >= 0 and torch.cuda.is_available() else "cpu"
+        super().__init__(
+            service_id=service_id,
+            ai_model_id=ai_model_id,
+            task=task,
+            device=resolved_device,
+            generator=generator,
+        )
+
+    async def get_text_contents(
+        self,
+        prompt: str,
+        settings: PromptExecutionSettings,
+    ) -> list[TextContent]:
+        """This is the method that is called from the kernel to get a response from a text-optimized LLM.
+
+        Args:
+            prompt (str): The prompt to send to the LLM.
+            settings (HuggingFacePromptExecutionSettings): Settings for the request.
+
+        Returns:
+            List[TextContent]: A list of TextContent objects representing the response(s) from the LLM.
+        """
+        if not isinstance(settings, HuggingFacePromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, HuggingFacePromptExecutionSettings)  # nosec
+
+        try:
+            results = self.generator(prompt, **settings.prepare_settings_dict())
+        except Exception as e:
+            raise ServiceResponseException("Hugging Face completion failed") from e
+        if isinstance(results, list):
+            return [self._create_text_content(results, result) for result in results]
+        return [self._create_text_content(results, results)]
+
+    def _create_text_content(self, response: Any, candidate: dict[str, str]) -> TextContent:
+        return TextContent(
+            inner_content=response,
+            ai_model_id=self.ai_model_id,
+            text=candidate["summary_text" if self.task == "summarization" else "generated_text"],
+        )
+
+    async def get_streaming_text_contents(
+        self,
+        prompt: str,
+        settings: PromptExecutionSettings,
+    ) -> AsyncGenerator[list[StreamingTextContent], Any]:
+        """Streams a text completion using a Hugging Face model.
+
+        Note that this method does not support multiple responses.
+
+        Args:
+            prompt (str): Prompt to complete.
+            settings (HuggingFacePromptExecutionSettings): Request settings.
+
+        Yields:
+            List[StreamingTextContent]: List of StreamingTextContent objects.
+        """
+        if not isinstance(settings, HuggingFacePromptExecutionSettings):
+            settings = self.get_prompt_execution_settings_from_settings(settings)
+        assert isinstance(settings, HuggingFacePromptExecutionSettings)  # nosec
+
+        if settings.num_return_sequences > 1:
+            raise ServiceInvalidExecutionSettingsError(
+                "HuggingFace TextIteratorStreamer does not stream multiple responses in a parseable format. \
+                    If you need multiple responses, please use the complete method.",
+            )
+        try:
+            streamer = TextIteratorStreamer(AutoTokenizer.from_pretrained(self.ai_model_id))
+            # See https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L159
+            thread = Thread(
+                target=self.generator, args={prompt}, kwargs=settings.prepare_settings_dict(streamer=streamer)
+            )
+            thread.start()
+
+            for new_text in streamer:
+                yield [
+                    StreamingTextContent(
+                        choice_index=0, inner_content=new_text, text=new_text, ai_model_id=self.ai_model_id
+                    )
+                ]
+
+            thread.join()
+        except Exception as e:
+            raise ServiceResponseException("Hugging Face completion failed") from e
+
+    @override
+    def get_prompt_execution_settings_class(self) -> type["PromptExecutionSettings"]:
+        """Create a request settings object."""
+        return HuggingFacePromptExecutionSettings

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/hugging_face/services/hf_text_embedding.py

@@ -0,0 +1,83 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+import sys
+from typing import TYPE_CHECKING, Any
+
+if sys.version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+import sentence_transformers
+import torch
+from numpy import ndarray
+
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import EmbeddingGeneratorBase
+from semantic_kernel.exceptions import ServiceResponseException
+from semantic_kernel.utils.experimental_decorator import experimental_class
+
+if TYPE_CHECKING:
+    from torch import Tensor
+
+    from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@experimental_class
+class HuggingFaceTextEmbedding(EmbeddingGeneratorBase):
+    """Hugging Face text embedding service."""
+
+    device: str
+    generator: Any
+
+    def __init__(
+        self,
+        ai_model_id: str,
+        device: int = -1,
+        service_id: str | None = None,
+    ) -> None:
+        """Initializes a new instance of the HuggingFaceTextEmbedding class.
+
+        Args:
+            ai_model_id (str): Hugging Face model card string, see
+                https://huggingface.co/sentence-transformers
+            device (int): Device to run the model on, -1 for CPU, 0+ for GPU. (optional)
+            service_id (str): Service ID for the model. (optional)
+
+        Note that this model will be downloaded from the Hugging Face model hub.
+        """
+        resolved_device = f"cuda:{device}" if device >= 0 and torch.cuda.is_available() else "cpu"
+        super().__init__(
+            ai_model_id=ai_model_id,
+            service_id=service_id,
+            device=resolved_device,
+            generator=sentence_transformers.SentenceTransformer(model_name_or_path=ai_model_id, device=resolved_device),
+        )
+
+    @override
+    async def generate_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> ndarray:
+        try:
+            logger.info(f"Generating embeddings for {len(texts)} texts.")
+            return self.generator.encode(sentences=texts, convert_to_numpy=True, **kwargs)
+        except Exception as e:
+            raise ServiceResponseException("Hugging Face embeddings failed", e) from e
+
+    @override
+    async def generate_raw_embeddings(
+        self,
+        texts: list[str],
+        settings: "PromptExecutionSettings | None" = None,
+        **kwargs: Any,
+    ) -> "list[Tensor] | ndarray | Tensor":
+        try:
+            logger.info(f"Generating raw embeddings for {len(texts)} texts.")
+            return self.generator.encode(sentences=texts, **kwargs)
+        except Exception as e:
+            raise ServiceResponseException("Hugging Face embeddings failed", e) from e

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/mistral_ai/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.ai.mistral_ai.prompt_execution_settings.mistral_ai_prompt_execution_settings import (
+    MistralAIChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.mistral_ai.services.mistral_ai_chat_completion import MistralAIChatCompletion
+from semantic_kernel.connectors.ai.mistral_ai.services.mistral_ai_text_embedding import MistralAITextEmbedding
+
+__all__ = [
+    "MistralAIChatCompletion",
+    "MistralAIChatPromptExecutionSettings",
+    "MistralAITextEmbedding",
+]

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/mistral_ai/prompt_execution_settings/mistral_ai_prompt_execution_settings.py

@@ -0,0 +1,38 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import logging
+from typing import Any, Literal
+
+from pydantic import Field, model_validator
+
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+
+logger = logging.getLogger(__name__)
+
+
+class MistralAIPromptExecutionSettings(PromptExecutionSettings):
+    """Common request settings for MistralAI services."""
+
+    ai_model_id: str | None = Field(None, serialization_alias="model")
+
+
+class MistralAIChatPromptExecutionSettings(MistralAIPromptExecutionSettings):
+    """Specific settings for the Chat Completion endpoint."""
+
+    response_format: dict[Literal["type"], Literal["text", "json_object"]] | None = None
+    messages: list[dict[str, Any]] | None = None
+    safe_mode: bool = False
+    safe_prompt: bool = False
+    max_tokens: int | None = Field(None, gt=0)
+    seed: int | None = None
+    temperature: float | None = Field(None, ge=0.0, le=2.0)
+    top_p: float | None = Field(None, ge=0.0, le=1.0)
+    random_seed: int | None = None
+
+    @model_validator(mode="after")
+    def check_function_call_behavior(self) -> "MistralAIChatPromptExecutionSettings":
+        """Check if the user is requesting function call behavior."""
+        if self.function_choice_behavior is not None:
+            raise NotImplementedError("MistralAI does not support function call behavior.")
+            
+        return self

semantic_kernel-1.8.3/semantic_kernel/connectors/ai/mistral_ai/services/mistral_ai_base.py

@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC
+from typing import ClassVar
+
+from mistralai.async_client import MistralAsyncClient
+
+from semantic_kernel.kernel_pydantic import KernelBaseModel
+
+
+class MistralAIBase(KernelBaseModel, ABC):
+    """Mistral AI service base."""
+
+    MODEL_PROVIDER_NAME: ClassVar[str] = "mistralai"
+
+    async_client: MistralAsyncClient