semantic-kernel 0.2.4.dev0__py3-none-any.whl → 0.2.5.dev0__py3-none-any.whl

semantic_kernel/kernel_config.py

@@ -2,11 +2,15 @@
 
 from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Type, TypeVar, Union
 
-from semantic_kernel.ai.chat_completion_client_base import ChatCompletionClientBase
-from semantic_kernel.ai.embeddings.embedding_generator_base import (
+from semantic_kernel.connectors.ai.chat_completion_client_base import (
+    ChatCompletionClientBase,
+)
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import (
     EmbeddingGeneratorBase,
 )
-from semantic_kernel.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.connectors.ai.text_completion_client_base import (
+    TextCompletionClientBase,
+)
 from semantic_kernel.reliability.pass_through_without_retry import (
     PassThroughWithoutRetry,
 )
@@ -21,231 +25,236 @@ T = TypeVar("T")
 
 class KernelConfig:
     def __init__(self) -> None:
-        self._text_backends: Dict[
+        self._text_services: Dict[
             str, Callable[["KernelBase"], TextCompletionClientBase]
         ] = {}
-        self._chat_backends: Dict[
+        self._chat_services: Dict[
             str, Callable[["KernelBase"], ChatCompletionClientBase]
         ] = {}
-        self._embedding_backends: Dict[
+        self._embedding_services: Dict[
             str, Callable[["KernelBase"], EmbeddingGeneratorBase]
         ] = {}
 
-        self._default_text_backend: Optional[str] = None
-        self._default_chat_backend: Optional[str] = None
-        self._default_embedding_backend: Optional[str] = None
+        self._default_text_service: Optional[str] = None
+        self._default_chat_service: Optional[str] = None
+        self._default_embedding_service: Optional[str] = None
 
         self._retry_mechanism: RetryMechanism = PassThroughWithoutRetry()
 
-    def get_ai_backend(
+    def get_ai_service(
         self, type: Type[T], service_id: Optional[str] = None
     ) -> Callable[["KernelBase"], T]:
         matching_type = {}
         if type == TextCompletionClientBase:
-            service_id = service_id or self._default_text_backend
-            matching_type = self._text_backends
+            service_id = service_id or self._default_text_service
+            matching_type = self._text_services
         elif type == ChatCompletionClientBase:
-            service_id = service_id or self._default_chat_backend
-            matching_type = self._chat_backends
+            service_id = service_id or self._default_chat_service
+            matching_type = self._chat_services
         elif type == EmbeddingGeneratorBase:
-            service_id = service_id or self._default_embedding_backend
-            matching_type = self._embedding_backends
+            service_id = service_id or self._default_embedding_service
+            matching_type = self._embedding_services
         else:
-            raise ValueError(f"Unknown backend type: {type.__name__}")
+            raise ValueError(f"Unknown AI service type: {type.__name__}")
 
         if service_id not in matching_type:
             raise ValueError(
-                f"{type.__name__} backend with service_id '{service_id}' not found"
+                f"{type.__name__} service with service_id '{service_id}' not found"
             )
 
         return matching_type[service_id]
 
-    def all_text_backends(self) -> List[str]:
-        return list(self._text_backends.keys())
+    def all_text_services(self) -> List[str]:
+        return list(self._text_services.keys())
 
-    def all_chat_backends(self) -> List[str]:
-        return list(self._chat_backends.keys())
+    def all_chat_services(self) -> List[str]:
+        return list(self._chat_services.keys())
 
-    def all_embedding_backends(self) -> List[str]:
-        return list(self._embedding_backends.keys())
+    def all_embedding_services(self) -> List[str]:
+        return list(self._embedding_services.keys())
 
-    def add_text_backend(
+    def add_text_service(
         self,
         service_id: str,
-        backend: Union[
+        service: Union[
             TextCompletionClientBase, Callable[["KernelBase"], TextCompletionClientBase]
         ],
         overwrite: bool = True,
     ) -> "KernelConfig":
         if not service_id:
             raise ValueError("service_id must be a non-empty string")
-        if not overwrite and service_id in self._text_backends:
+        if not overwrite and service_id in self._text_services:
             raise ValueError(
-                f"Text backend with service_id '{service_id}' already exists"
+                f"Text service with service_id '{service_id}' already exists"
             )
 
-        self._text_backends[service_id] = (
-            backend if isinstance(backend, Callable) else lambda _: backend
+        self._text_services[service_id] = (
+            service if isinstance(service, Callable) else lambda _: service
         )
-        if self._default_text_backend is None:
-            self._default_text_backend = service_id
+        if self._default_text_service is None:
+            self._default_text_service = service_id
 
         return self
 
-    def add_chat_backend(
+    def add_chat_service(
         self,
         service_id: str,
-        backend: Union[
+        service: Union[
             ChatCompletionClientBase, Callable[["KernelBase"], ChatCompletionClientBase]
         ],
         overwrite: bool = True,
     ) -> "KernelConfig":
         if not service_id:
             raise ValueError("service_id must be a non-empty string")
-        if not overwrite and service_id in self._chat_backends:
+        if not overwrite and service_id in self._chat_services:
             raise ValueError(
-                f"Chat backend with service_id '{service_id}' already exists"
+                f"Chat service with service_id '{service_id}' already exists"
             )
 
-        self._chat_backends[service_id] = (
-            backend if isinstance(backend, Callable) else lambda _: backend
+        self._chat_services[service_id] = (
+            service if isinstance(service, Callable) else lambda _: service
         )
-        if self._default_chat_backend is None:
-            self._default_chat_backend = service_id
+        if self._default_chat_service is None:
+            self._default_chat_service = service_id
+
+        if isinstance(service, TextCompletionClientBase):
+            self.add_text_service(service_id, service)
+            if self._default_text_service is None:
+                self._default_text_service = service_id
 
         return self
 
-    def add_embedding_backend(
+    def add_embedding_service(
         self,
         service_id: str,
-        backend: Union[
+        service: Union[
             EmbeddingGeneratorBase, Callable[["KernelBase"], EmbeddingGeneratorBase]
         ],
         overwrite: bool = False,
     ) -> "KernelConfig":
         if not service_id:
             raise ValueError("service_id must be a non-empty string")
-        if not overwrite and service_id in self._embedding_backends:
+        if not overwrite and service_id in self._embedding_services:
             raise ValueError(
-                f"Embedding backend with service_id '{service_id}' already exists"
+                f"Embedding service with service_id '{service_id}' already exists"
             )
 
-        self._embedding_backends[service_id] = (
-            backend if isinstance(backend, Callable) else lambda _: backend
+        self._embedding_services[service_id] = (
+            service if isinstance(service, Callable) else lambda _: service
         )
-        if self._default_embedding_backend is None:
-            self._default_embedding_backend = service_id
+        if self._default_embedding_service is None:
+            self._default_embedding_service = service_id
 
         return self
 
     # TODO: look harder at retry stuff
 
-    def set_default_text_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._text_backends:
+    def set_default_text_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._text_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        self._default_text_backend = service_id
+        self._default_text_service = service_id
         return self
 
-    def set_default_chat_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._chat_backends:
+    def set_default_chat_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._chat_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        self._default_chat_backend = service_id
+        self._default_chat_service = service_id
         return self
 
-    def set_default_embedding_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._embedding_backends:
+    def set_default_embedding_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._embedding_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        self._default_embedding_backend = service_id
+        self._default_embedding_service = service_id
         return self
 
-    def get_text_backend_service_id(self, service_id: Optional[str] = None) -> str:
-        if service_id is None or service_id not in self._text_backends:
-            if self._default_text_backend is None:
-                raise ValueError("No default text backend is set")
-            return self._default_text_backend
+    def get_text_service_service_id(self, service_id: Optional[str] = None) -> str:
+        if service_id is None or service_id not in self._text_services:
+            if self._default_text_service is None:
+                raise ValueError("No default text service is set")
+            return self._default_text_service
 
         return service_id
 
-    def get_chat_backend_service_id(self, service_id: Optional[str] = None) -> str:
-        if service_id is None or service_id not in self._chat_backends:
-            if self._default_chat_backend is None:
-                raise ValueError("No default chat backend is set")
-            return self._default_chat_backend
+    def get_chat_service_service_id(self, service_id: Optional[str] = None) -> str:
+        if service_id is None or service_id not in self._chat_services:
+            if self._default_chat_service is None:
+                raise ValueError("No default chat service is set")
+            return self._default_chat_service
 
         return service_id
 
-    def get_embedding_backend_service_id(self, service_id: Optional[str] = None) -> str:
-        if service_id is None or service_id not in self._embedding_backends:
-            if self._default_embedding_backend is None:
-                raise ValueError("No default embedding backend is set")
-            return self._default_embedding_backend
+    def get_embedding_service_id(self, service_id: Optional[str] = None) -> str:
+        if service_id is None or service_id not in self._embedding_services:
+            if self._default_embedding_service is None:
+                raise ValueError("No default embedding service is set")
+            return self._default_embedding_service
 
         return service_id
 
-    def remove_text_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._text_backends:
+    def remove_text_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._text_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        del self._text_backends[service_id]
-        if self._default_text_backend == service_id:
-            self._default_text_backend = next(iter(self._text_backends), None)
+        del self._text_services[service_id]
+        if self._default_text_service == service_id:
+            self._default_text_service = next(iter(self._text_services), None)
         return self
 
-    def remove_chat_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._chat_backends:
+    def remove_chat_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._chat_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        del self._chat_backends[service_id]
-        if self._default_chat_backend == service_id:
-            self._default_chat_backend = next(iter(self._chat_backends), None)
+        del self._chat_services[service_id]
+        if self._default_chat_service == service_id:
+            self._default_chat_service = next(iter(self._chat_services), None)
         return self
 
-    def remove_embedding_backend(self, service_id: str) -> "KernelConfig":
-        if service_id not in self._embedding_backends:
+    def remove_embedding_service(self, service_id: str) -> "KernelConfig":
+        if service_id not in self._embedding_services:
             raise ValueError(
-                f"AI backend with service_id '{service_id}' does not exist"
+                f"AI service with service_id '{service_id}' does not exist"
             )
 
-        del self._embedding_backends[service_id]
-        if self._default_embedding_backend == service_id:
-            self._default_embedding_backend = next(iter(self._embedding_backends), None)
+        del self._embedding_services[service_id]
+        if self._default_embedding_service == service_id:
+            self._default_embedding_service = next(iter(self._embedding_services), None)
         return self
 
-    def clear_all_text_backends(self) -> "KernelConfig":
-        self._text_backends = {}
-        self._default_text_backend = None
+    def clear_all_text_services(self) -> "KernelConfig":
+        self._text_services = {}
+        self._default_text_service = None
         return self
 
-    def clear_all_chat_backends(self) -> "KernelConfig":
-        self._chat_backends = {}
-        self._default_chat_backend = None
+    def clear_all_chat_services(self) -> "KernelConfig":
+        self._chat_services = {}
+        self._default_chat_service = None
         return self
 
-    def clear_all_embedding_backends(self) -> "KernelConfig":
-        self._embedding_backends = {}
-        self._default_embedding_backend = None
+    def clear_all_embedding_services(self) -> "KernelConfig":
+        self._embedding_services = {}
+        self._default_embedding_service = None
         return self
 
-    def clear_all_backends(self) -> "KernelConfig":
-        self._text_backends = {}
-        self._chat_backends = {}
-        self._embedding_backends = {}
+    def clear_all_services(self) -> "KernelConfig":
+        self._text_services = {}
+        self._chat_services = {}
+        self._embedding_services = {}
 
-        self._default_text_backend = None
-        self._default_chat_backend = None
-        self._default_embedding_backend = None
+        self._default_text_service = None
+        self._default_chat_service = None
+        self._default_embedding_service = None
 
         return self

semantic_kernel/kernel_exception.py

@@ -18,10 +18,10 @@ class KernelException(Exception):
         FunctionTypeNotSupported = 3
         # Invalid function type.
         InvalidFunctionType = 4
-        # Invalid backend configuration.
-        InvalidBackendConfiguration = 5
-        # Backend not found.
-        BackendNotFound = 6
+        # Invalid service configuration.
+        InvalidServiceConfiguration = 5
+        # Service not found.
+        ServiceNotFound = 6
         # Skill collection not set.
         SkillCollectionNotSet = 7
         # Ambiguous implementation.

semantic_kernel/kernel_extensions/import_skills.py

@@ -4,7 +4,6 @@ import glob
 import importlib
 import inspect
 import os
-import sys
 from typing import Dict
 
 from semantic_kernel.kernel_extensions.extends_kernel import ExtendsKernel
@@ -23,8 +22,7 @@ class ImportSkills(ExtendsKernel):
     def import_native_skill_from_directory(
         self, parent_directory: str, skill_directory_name: str
     ) -> Dict[str, SKFunctionBase]:
-        PYTHON_FILE = "native_function.py"
-
+        MODULE_NAME = "native_function"
         kernel = self.kernel()
 
         validate_skill_name(skill_directory_name)
@@ -32,7 +30,7 @@ class ImportSkills(ExtendsKernel):
         skill_directory = os.path.abspath(
             os.path.join(parent_directory, skill_directory_name)
         )
-        native_py_file_path = os.path.join(skill_directory, PYTHON_FILE)
+        native_py_file_path = os.path.join(skill_directory, f"{MODULE_NAME}.py")
 
         if not os.path.exists(native_py_file_path):
             raise ValueError(
@@ -41,25 +39,27 @@ class ImportSkills(ExtendsKernel):
 
         skill_name = os.path.basename(skill_directory)
         try:
-            sys.path.append(skill_directory)
-            module_name = os.path.splitext(os.path.basename(native_py_file_path))[0]
-            module = importlib.import_module(module_name)
+            spec = importlib.util.spec_from_file_location(
+                MODULE_NAME, native_py_file_path
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            class_name = next(
+                (
+                    name
+                    for name, cls in inspect.getmembers(module, inspect.isclass)
+                    if cls.__module__ == MODULE_NAME
+                ),
+                None,
+            )
+            if class_name:
+                skill_obj = getattr(module, class_name)()
+                return kernel.import_skill(skill_obj, skill_name)
         except Exception:
-            return {}
-        finally:
-            sys.path.remove(skill_directory)
-
-        # Find the class in the module
-        classes = inspect.getmembers(module, inspect.isclass)
-        class_name = next(
-            (name for name, cls in classes if inspect.getmodule(cls) == module), None
-        )
+            pass
 
-        if class_name:
-            skill_obj = getattr(module, class_name)()
-            return kernel.import_skill(skill_obj, skill_name)
-        else:
-            return {}
+        return {}
 
     def import_semantic_skill_from_directory(
         self, parent_directory: str, skill_directory_name: str

semantic_kernel/kernel_extensions/memory_configuration.py

@@ -2,7 +2,7 @@
 
 from typing import Optional
 
-from semantic_kernel.ai.embeddings.embedding_generator_base import (
+from semantic_kernel.connectors.ai.embeddings.embedding_generator_base import (
     EmbeddingGeneratorBase,
 )
 from semantic_kernel.kernel_extensions.extends_kernel import ExtendsKernel
@@ -19,19 +19,17 @@ class MemoryConfiguration(ExtendsKernel):
         kernel = self.kernel()
 
         if embeddings_generator is None:
-            backend_label = kernel.config.get_embedding_backend_service_id()
-            if not backend_label:
-                raise ValueError(
-                    "The embedding backend label cannot be `None` or empty"
-                )
-
-            embeddings_backend = kernel.config.get_ai_backend(
-                EmbeddingGeneratorBase, backend_label
+            service_id = kernel.config.get_embedding_service_id()
+            if not service_id:
+                raise ValueError("The embedding service id cannot be `None` or empty")
+
+            embeddings_service = kernel.config.get_ai_service(
+                EmbeddingGeneratorBase, service_id
             )
-            if not embeddings_backend:
-                raise ValueError(f"AI configuration is missing for: {backend_label}")
+            if not embeddings_service:
+                raise ValueError(f"AI configuration is missing for: {service_id}")
 
-            embeddings_generator = embeddings_backend(kernel)
+            embeddings_generator = embeddings_service(kernel)
 
         if storage is None:
             raise ValueError("The storage instance provided cannot be `None`")

semantic_kernel/memory/memory_query_result.py

@@ -2,6 +2,8 @@
 
 from typing import Optional
 
+from numpy import ndarray
+
 from semantic_kernel.memory.memory_record import MemoryRecord
 
 
@@ -12,6 +14,7 @@ class MemoryQueryResult:
     description: Optional[str]
     text: Optional[str]
     relevance: float
+    embedding: Optional[ndarray]
 
     def __init__(
         self,
@@ -20,24 +23,51 @@ class MemoryQueryResult:
         id: str,
         description: Optional[str],
         text: Optional[str],
+        embedding: Optional[ndarray],
         relevance: float,
     ) -> None:
+        """Initialize a new instance of MemoryQueryResult.
+
+        Arguments:
+            is_reference {bool} -- Whether the record is a reference record.
+            external_source_name {Optional[str]} -- The name of the external source.
+            id {str} -- A unique for the record.
+            description {Optional[str]} -- The description of the record.
+            text {Optional[str]} -- The text of the record.
+            embedding {ndarray} -- The embedding of the record.
+            relevance {float} -- The relevance of the record to a known query.
+
+        Returns:
+            None -- None.
+        """
         self.is_reference = is_reference
         self.external_source_name = external_source_name
         self.id = id
         self.description = description
         self.text = text
         self.relevance = relevance
+        self.embedding = embedding
 
     @staticmethod
     def from_memory_record(
-        record: MemoryRecord, relevance: float
+        record: MemoryRecord,
+        relevance: float,
     ) -> "MemoryQueryResult":
+        """Create a new instance of MemoryQueryResult from a MemoryRecord.
+
+        Arguments:
+            record {MemoryRecord} -- The MemoryRecord to create the MemoryQueryResult from.
+            relevance {float} -- The relevance of the record to a known query.
+
+        Returns:
+            MemoryQueryResult -- The created MemoryQueryResult.
+        """
         return MemoryQueryResult(
-            is_reference=record.is_reference,
-            external_source_name=record.external_source_name,
-            id=record.id,
-            description=record.description,
-            text=record.text,
+            is_reference=record._is_reference,
+            external_source_name=record._external_source_name,
+            id=record._id,
+            description=record._description,
+            text=record._text,
+            embedding=record._embedding,
             relevance=relevance,
         )

semantic_kernel/memory/memory_record.py

@@ -6,11 +6,13 @@ from numpy import ndarray
 
 
 class MemoryRecord:
-    is_reference: bool
-    external_source_name: Optional[str]
-    id: str
-    description: Optional[str]
-    text: Optional[str]
+    _key: str
+    _timestamp: str
+    _is_reference: bool
+    _external_source_name: Optional[str]
+    _id: str
+    _description: Optional[str]
+    _text: Optional[str]
     _embedding: ndarray
 
     def __init__(
@@ -21,17 +23,34 @@ class MemoryRecord:
         description: Optional[str],
         text: Optional[str],
         embedding: ndarray,
+        key: Optional[str] = None,
+        timestamp: Optional[str] = None,
     ) -> None:
-        self.is_reference = is_reference
-        self.external_source_name = external_source_name
-        self.id = id
-        self.description = description
-        self.text = text
+        """Initialize a new instance of MemoryRecord.
+
+        Arguments:
+            is_reference {bool} -- Whether the record is a reference record.
+            external_source_name {Optional[str]} -- The name of the external source.
+            id {str} -- A unique for the record.
+            description {Optional[str]} -- The description of the record.
+            text {Optional[str]} -- The text of the record.
+            embedding {ndarray} -- The embedding of the record.
+
+        Returns:
+            None -- None.
+        """
+        self._key = key
+        self._timestamp = timestamp
+        self._is_reference = is_reference
+        self._external_source_name = external_source_name
+        self._id = id
+        self._description = description
+        self._text = text
         self._embedding = embedding
 
     @property
     def embedding(self) -> ndarray:
-        return self._embedding
+        return self.embedding
 
     @staticmethod
     def reference_record(
@@ -40,6 +59,17 @@ class MemoryRecord:
         description: Optional[str],
         embedding: ndarray,
     ) -> "MemoryRecord":
+        """Create a reference record.
+
+        Arguments:
+            external_id {str} -- The external id of the record.
+            source_name {str} -- The name of the external source.
+            description {Optional[str]} -- The description of the record.
+            embedding {ndarray} -- The embedding of the record.
+
+        Returns:
+            MemoryRecord -- The reference record.
+        """
         return MemoryRecord(
             is_reference=True,
             external_source_name=source_name,
@@ -53,6 +83,17 @@ class MemoryRecord:
     def local_record(
         id: str, text: str, description: Optional[str], embedding: ndarray
     ) -> "MemoryRecord":
+        """Create a local record.
+
+        Arguments:
+            id {str} -- A unique for the record.
+            text {str} -- The text of the record.
+            description {Optional[str]} -- The description of the record.
+            embedding {ndarray} -- The embedding of the record.
+
+        Returns:
+            MemoryRecord -- The local record.
+        """
         return MemoryRecord(
             is_reference=False,
             external_source_name=None,