semantic-kernel 0.3.0.dev0__tar.gz → 0.3.2.dev0__tar.gz

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantic-kernel
-Version: 0.3.0.dev0
+Version: 0.3.2.dev0
 Summary: 
 Author: Microsoft
 Author-email: SK-Support@microsoft.com
@@ -13,6 +13,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: aiofiles (>=23.1.0,<24.0.0)
 Requires-Dist: numpy (>=1.24.2,<2.0.0)
 Requires-Dist: openai (>=0.27.0,<0.28.0)
+Requires-Dist: python-dotenv (==1.0.0)
+Requires-Dist: regex (>=2023.6.3,<2024.0.0)
 Description-Content-Type: text/markdown
 
 # About Semantic Kernel

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-kernel"
-version = "0.3.0.dev"
+version = "0.3.2.dev"
 description = ""
 authors = ["Microsoft <SK-Support@microsoft.com>"]
 readme = "pip/README.md"
@@ -11,15 +11,16 @@ python = "^3.8"
 numpy = "^1.24.2"
 openai = "^0.27.0"
 aiofiles = "^23.1.0"
+python-dotenv = "1.0.0"
+regex = "^2023.6.3"
 
 [tool.poetry.group.dev.dependencies]
-pre-commit = "^2.21.0"
-black = {version = "^23.3.0", allow-prereleases = true}
+pre-commit = "3.3.3"
+black = {version = "23.3.0", allow-prereleases = true}
 ipykernel = "^6.21.1"
-pytest = "7.2.0"
-ruff = "^0.0.257"
-pytest-asyncio = "^0.21.0"
-
+pytest = "7.4.0"
+ruff = "0.0.277"
+pytest-asyncio = "0.21.0"
 
 [tool.poetry.group.hugging_face.dependencies]
 transformers = "^4.28.1"
@@ -33,10 +34,14 @@ chromadb = "^0.3.23"
 [tool.poetry.group.weaviate.dependencies]
 weaviate-client = "^3.18.0"
 
+[tool.poetry.group.pinecone.dependencies]
+pinecone-client = "^2.2.2"
+
 [tool.isort]
 profile = "black"
 
 [tool.ruff]
+select = ["E", "F", "I"]
 line-length = 120
 
 [build-system]

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/__init__.py

@@ -17,6 +17,7 @@ from semantic_kernel.utils.null_logger import NullLogger
 from semantic_kernel.utils.settings import (
     azure_openai_settings_from_dot_env,
     openai_settings_from_dot_env,
+    pinecone_settings_from_dot_env,
 )
 
 __all__ = [
@@ -24,6 +25,7 @@ __all__ = [
     "NullLogger",
     "openai_settings_from_dot_env",
     "azure_openai_settings_from_dot_env",
+    "pinecone_settings_from_dot_env",
     "PromptTemplateConfig",
     "PromptTemplate",
     "ChatPromptTemplate",

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/ai/chat_completion_client_base.py

@@ -0,0 +1,52 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC, abstractmethod
+from logging import Logger
+from typing import TYPE_CHECKING, List, Tuple, Union
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.chat_request_settings import ChatRequestSettings
+
+
+class ChatCompletionClientBase(ABC):
+    @abstractmethod
+    async def complete_chat_async(
+        self,
+        messages: List[Tuple[str, str]],
+        settings: "ChatRequestSettings",
+        logger: Logger,
+    ) -> Union[str, List[str]]:
+        """
+        This is the method that is called from the kernel to get a response from a chat-optimized LLM.
+
+        Arguments:
+            messages {List[Tuple[str, str]]} -- A list of tuples, where each tuple is
+                comprised of a speaker ID and a message.
+            settings {ChatRequestSettings} -- Settings for the request.
+            logger {Logger} -- A logger to use for logging.
+
+        Returns:
+            Union[str, List[str]] -- A string or list of strings representing the response(s) from the LLM.
+        """
+        pass
+
+    @abstractmethod
+    async def complete_chat_stream_async(
+        self,
+        messages: List[Tuple[str, str]],
+        settings: "ChatRequestSettings",
+        logger: Logger,
+    ):
+        """
+        This is the method that is called from the kernel to get a stream response from a chat-optimized LLM.
+
+        Arguments:
+            messages {List[Tuple[str, str]]} -- A list of tuples, where each tuple is
+                comprised of a speaker ID and a message.
+            settings {ChatRequestSettings} -- Settings for the request.
+            logger {Logger} -- A logger to use for logging.
+
+        Yields:
+            A stream representing the response(s) from the LLM.
+        """
+        pass

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/ai/chat_request_settings.py

@@ -15,6 +15,7 @@ class ChatRequestSettings:
     top_p: float = 1.0
     presence_penalty: float = 0.0
     frequency_penalty: float = 0.0
+    number_of_responses: int = 1
     max_tokens: int = 256
 
     def update_from_completion_config(
@@ -24,6 +25,7 @@ class ChatRequestSettings:
         self.top_p = completion_config.top_p
         self.presence_penalty = completion_config.presence_penalty
         self.frequency_penalty = completion_config.frequency_penalty
+        self.number_of_responses = completion_config.number_of_responses
         self.max_tokens = completion_config.max_tokens
 
     @staticmethod

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/ai/complete_request_settings.py

@@ -29,6 +29,7 @@ class CompleteRequestSettings:
         self.frequency_penalty = completion_config.frequency_penalty
         self.max_tokens = completion_config.max_tokens
         self.stop_sequences = completion_config.stop_sequences
+        self.number_of_responses = completion_config.number_of_responses
 
     @staticmethod
     def from_completion_config(

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/ai/hugging_face/services/hf_text_completion.py

@@ -2,7 +2,7 @@
 
 from logging import Logger
 from threading import Thread
-from typing import Optional
+from typing import List, Optional, Union
 
 from semantic_kernel.connectors.ai.ai_exception import AIException
 from semantic_kernel.connectors.ai.complete_request_settings import (
@@ -64,17 +64,7 @@ class HuggingFaceTextCompletion(TextCompletionClientBase):
 
     async def complete_async(
         self, prompt: str, request_settings: CompleteRequestSettings
-    ) -> str:
-        """
-        Completes a prompt using the Hugging Face model.
-
-        Arguments:
-            prompt {str} -- Prompt to complete.
-            request_settings {CompleteRequestSettings} -- Request settings.
-
-        Returns:
-            str -- Completion result.
-        """
+    ) -> Union[str, List[str]]:
         try:
             import transformers
 
@@ -84,15 +74,30 @@ class HuggingFaceTextCompletion(TextCompletionClientBase):
                 max_new_tokens=request_settings.max_tokens,
                 pad_token_id=50256,  # EOS token
             )
-            result = self.generator(
-                prompt, num_return_sequences=1, generation_config=generation_config
+
+            results = self.generator(
+                prompt,
+                do_sample=True,
+                num_return_sequences=request_settings.number_of_responses,
+                generation_config=generation_config,
             )
 
+            completions = list()
             if self._task == "text-generation" or self._task == "text2text-generation":
-                return result[0]["generated_text"]
+                for response in results:
+                    completions.append(response["generated_text"])
+                if len(completions) == 1:
+                    return completions[0]
+                else:
+                    return completions
 
             elif self._task == "summarization":
-                return result[0]["summary_text"]
+                for response in results:
+                    completions.append(response["summary_text"])
+                if len(completions) == 1:
+                    return completions[0]
+                else:
+                    return completions
 
             else:
                 raise AIException(
@@ -107,6 +112,23 @@ class HuggingFaceTextCompletion(TextCompletionClientBase):
     async def complete_stream_async(
         self, prompt: str, request_settings: CompleteRequestSettings
     ):
+        """
+        Streams a text completion using a Hugging Face model.
+        Note that this method does not support multiple responses.
+
+        Arguments:
+            prompt {str} -- Prompt to complete.
+            request_settings {CompleteRequestSettings} -- Request settings.
+
+        Yields:
+            str -- Completion result.
+        """
+        if request_settings.number_of_responses > 1:
+            raise AIException(
+                AIException.ErrorCodes.InvalidConfiguration,
+                "HuggingFace TextIteratorStreamer does not stream multiple responses in a parseable format. \
+                    If you need multiple responses, please use the complete_async method.",
+            )
         try:
             import transformers
 
@@ -116,15 +138,18 @@ class HuggingFaceTextCompletion(TextCompletionClientBase):
                 max_new_tokens=request_settings.max_tokens,
                 pad_token_id=50256,  # EOS token
             )
+
             tokenizer = transformers.AutoTokenizer.from_pretrained(self._model_id)
             streamer = transformers.TextIteratorStreamer(tokenizer)
-            args = {"prompt": prompt}
+            args = {prompt}
             kwargs = {
-                "num_return_sequences": 1,
+                "num_return_sequences": request_settings.number_of_responses,
                 "generation_config": generation_config,
                 "streamer": streamer,
+                "do_sample": True,
             }
 
+            # See https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L159
             thread = Thread(target=self.generator, args=args, kwargs=kwargs)
             thread.start()
 

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/ai/open_ai/services/open_ai_chat_completion.py

@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 from logging import Logger
-from typing import Any, List, Optional, Tuple
+from typing import Any, List, Optional, Tuple, Union
 
 import openai
 
@@ -61,28 +61,37 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
 
     async def complete_chat_async(
         self, messages: List[Tuple[str, str]], request_settings: ChatRequestSettings
-    ) -> str:
+    ) -> Union[str, List[str]]:
         # TODO: tracking on token counts/etc.
         response = await self._send_chat_request(messages, request_settings, False)
 
-        return response.choices[0].message.content
+        if len(response.choices) == 1:
+            return response.choices[0].message.content
+        else:
+            return [choice.message.content for choice in response.choices]
 
     async def complete_chat_stream_async(
         self, messages: List[Tuple[str, str]], request_settings: ChatRequestSettings
     ):
         response = await self._send_chat_request(messages, request_settings, True)
+
+        # parse the completion text(s) and yield them
         async for chunk in response:
-            if "role" in chunk.choices[0].delta:
-                yield chunk.choices[0].delta.role + ": "
-            if "content" in chunk.choices[0].delta:
-                yield chunk.choices[0].delta.content
+            text, index = _parse_choices(chunk)
+            # if multiple responses are requested, keep track of them
+            if request_settings.number_of_responses > 1:
+                completions = [""] * request_settings.number_of_responses
+                completions[index] = text
+                yield completions
+            # if only one response is requested, yield it
+            else:
+                yield text
 
     async def complete_async(
         self, prompt: str, request_settings: CompleteRequestSettings
-    ) -> str:
+    ) -> Union[str, List[str]]:
         """
-        Completes the given prompt. Returns a single string completion.
-        Cannot return multiple completions. Cannot return logprobs.
+        Completes the given prompt.
 
         Arguments:
             prompt {str} -- The prompt to complete.
@@ -98,12 +107,16 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
             presence_penalty=request_settings.presence_penalty,
             frequency_penalty=request_settings.frequency_penalty,
             max_tokens=request_settings.max_tokens,
+            number_of_responses=request_settings.number_of_responses,
         )
         response = await self._send_chat_request(
             prompt_to_message, chat_settings, False
         )
 
-        return response.choices[0].message.content
+        if len(response.choices) == 1:
+            return response.choices[0].message.content
+        else:
+            return [choice.message.content for choice in response.choices]
 
     async def complete_stream_async(
         self, prompt: str, request_settings: CompleteRequestSettings
@@ -115,12 +128,21 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
             presence_penalty=request_settings.presence_penalty,
             frequency_penalty=request_settings.frequency_penalty,
             max_tokens=request_settings.max_tokens,
+            number_of_responses=request_settings.number_of_responses,
         )
         response = await self._send_chat_request(prompt_to_message, chat_settings, True)
 
+        # parse the completion text(s) and yield them
         async for chunk in response:
-            if "content" in chunk.choices[0].delta:
-                yield chunk.choices[0].delta.content
+            text, index = _parse_choices(chunk)
+            # if multiple responses are requested, keep track of them
+            if request_settings.number_of_responses > 1:
+                completions = [""] * request_settings.number_of_responses
+                completions[index] = text
+                yield completions
+            # if only one response is requested, yield it
+            else:
+                yield text
 
     async def _send_chat_request(
         self,
@@ -129,7 +151,7 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
         stream: bool,
     ):
         """
-        Completes the given user message. Returns a single string completion.
+        Completes the given user message with an asynchronous stream.
 
         Arguments:
             user_message {str} -- The message (from a user) to respond to.
@@ -184,6 +206,7 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
                 presence_penalty=request_settings.presence_penalty,
                 frequency_penalty=request_settings.frequency_penalty,
                 max_tokens=request_settings.max_tokens,
+                n=request_settings.number_of_responses,
                 stream=stream,
             )
         except Exception as ex:
@@ -196,3 +219,14 @@ class OpenAIChatCompletion(ChatCompletionClientBase, TextCompletionClientBase):
         # TODO: tracking on token counts/etc.
 
         return response
+
+
+def _parse_choices(chunk):
+    message = ""
+    if "role" in chunk.choices[0].delta:
+        message += chunk.choices[0].delta.role + ": "
+    if "content" in chunk.choices[0].delta:
+        message += chunk.choices[0].delta.content
+
+    index = chunk.choices[0].index
+    return message, index

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/ai/open_ai/services/open_ai_text_completion.py

@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 from logging import Logger
-from typing import Any, Optional
+from typing import Any, List, Optional, Union
 
 import openai
 
@@ -56,10 +56,14 @@ class OpenAITextCompletion(TextCompletionClientBase):
 
     async def complete_async(
         self, prompt: str, request_settings: CompleteRequestSettings
-    ) -> str:
+    ) -> Union[str, List[str]]:
         # TODO: tracking on token counts/etc.
         response = await self._send_completion_request(prompt, request_settings, False)
-        return response.choices[0].text
+
+        if len(response.choices) == 1:
+            return response.choices[0].text
+        else:
+            return [choice.text for choice in response.choices]
 
     # TODO: complete w/ multiple...
 
@@ -67,8 +71,15 @@ class OpenAITextCompletion(TextCompletionClientBase):
         self, prompt: str, request_settings: CompleteRequestSettings
     ):
         response = await self._send_completion_request(prompt, request_settings, True)
+
         async for chunk in response:
-            yield chunk.choices[0].text
+            if request_settings.number_of_responses > 1:
+                for choice in chunk.choices:
+                    completions = [""] * request_settings.number_of_responses
+                    completions[choice.index] = choice.text
+                    yield completions
+            else:
+                yield chunk.choices[0].text
 
     async def _send_completion_request(
         self, prompt: str, request_settings: CompleteRequestSettings, stream: bool
@@ -96,13 +107,6 @@ class OpenAITextCompletion(TextCompletionClientBase):
                 f"but was {request_settings.max_tokens}",
             )
 
-        if request_settings.number_of_responses != 1:
-            raise AIException(
-                AIException.ErrorCodes.InvalidRequest,
-                "complete_async only supports a single completion, "
-                f"but {request_settings.number_of_responses} were requested",
-            )
-
         if request_settings.logprobs != 0:
             raise AIException(
                 AIException.ErrorCodes.InvalidRequest,
@@ -131,6 +135,7 @@ class OpenAITextCompletion(TextCompletionClientBase):
                 frequency_penalty=request_settings.frequency_penalty,
                 max_tokens=request_settings.max_tokens,
                 stream=stream,
+                n=request_settings.number_of_responses,
                 stop=(
                     request_settings.stop_sequences
                     if request_settings.stop_sequences is not None

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/ai/text_completion_client_base.py

@@ -0,0 +1,52 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC, abstractmethod
+from logging import Logger
+from typing import TYPE_CHECKING, List, Union
+
+if TYPE_CHECKING:
+    from semantic_kernel.connectors.ai.complete_request_settings import (
+        CompleteRequestSettings,
+    )
+
+
+class TextCompletionClientBase(ABC):
+    @abstractmethod
+    async def complete_async(
+        self,
+        prompt: str,
+        settings: "CompleteRequestSettings",
+        logger: Logger,
+    ) -> Union[str, List[str]]:
+        """
+        This is the method that is called from the kernel to get a response from a text-optimized LLM.
+
+        Arguments:
+            prompt {str} -- The prompt to send to the LLM.
+            settings {CompleteRequestSettings} -- Settings for the request.
+            logger {Logger} -- A logger to use for logging.
+
+            Returns:
+                Union[str, List[str]] -- A string or list of strings representing the response(s) from the LLM.
+        """
+        pass
+
+    @abstractmethod
+    async def complete_stream_async(
+        self,
+        prompt: str,
+        settings: "CompleteRequestSettings",
+        logger: Logger,
+    ):
+        """
+        This is the method that is called from the kernel to get a stream response from a text-optimized LLM.
+
+        Arguments:
+            prompt {str} -- The prompt to send to the LLM.
+            settings {CompleteRequestSettings} -- Settings for the request.
+            logger {Logger} -- A logger to use for logging.
+
+        Yields:
+            A stream representing the response(s) from the LLM.
+        """
+        pass

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/memory/chroma/chroma_memory_store.py

@@ -158,12 +158,14 @@ class ChromaMemoryStore(MemoryStoreBase):
         if collection is None:
             raise Exception(f"Collection '{collection_name}' does not exist")
 
-        # TODO: timestamp
+        record._key = record._id
         metadata = {
             "timestamp": record._timestamp or "",
             "is_reference": record._is_reference,
             "external_source_name": record._external_source_name or "",
             "description": record._description or "",
+            "additional_metadata": record._additional_metadata or "",
+            "id": record._id or "",
         }
 
         collection.add(
@@ -171,11 +173,12 @@ class ChromaMemoryStore(MemoryStoreBase):
             # by providing embeddings, we can skip the chroma's embedding function call
             embeddings=record.embedding.tolist(),
             documents=record._text,
-            ids=record._id,
+            ids=record._key,
         )
+
         if self._persist_directory is not None:
             self._client.persist()
-        return record._id
+        return record._key
 
     async def upsert_batch_async(
         self, collection_name: str, records: List[MemoryRecord]
@@ -237,7 +240,7 @@ class ChromaMemoryStore(MemoryStoreBase):
         )
 
         value = collection.get(ids=keys, include=query_includes)
-        record = query_results_to_records(value)
+        record = query_results_to_records(value, with_embeddings)
         return record
 
     async def remove_async(self, collection_name: str, key: str) -> None:
@@ -318,7 +321,7 @@ class ChromaMemoryStore(MemoryStoreBase):
         record_list = [
             (record, distance)
             for record, distance in zip(
-                query_results_to_records(query_results),
+                query_results_to_records(query_results, with_embeddings),
                 similarity_score,
             )
         ]

{semantic_kernel-0.3.0.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/connectors/memory/chroma/utils.py

@@ -22,7 +22,9 @@ def camel_to_snake(camel_str):
     return snake_str
 
 
-def query_results_to_records(results: "QueryResult") -> List[MemoryRecord]:
+def query_results_to_records(
+    results: "QueryResult", with_embedding: bool
+) -> List[MemoryRecord]:
     # if results has only one record, it will be a list instead of a nested list
     # this is to make sure that results is always a nested list
     # {'ids': ['test_id1'], 'embeddings': [[...]], 'documents': ['sample text1'], 'metadatas': [{...}]}
@@ -34,28 +36,49 @@ def query_results_to_records(results: "QueryResult") -> List[MemoryRecord]:
     except IndexError:
         return []
 
-    memory_records = [
-        (
-            MemoryRecord(
-                is_reference=metadata["is_reference"],
-                external_source_name=metadata["external_source_name"],
-                id=id,
-                description=metadata["description"],
-                text=document,
-                # TODO: get_async say embedding is optional but Record constructor requires it
-                embedding=embedding,
-                # TODO: what is key for?
-                key=None,
-                timestamp=metadata["timestamp"],
+    if with_embedding:
+        memory_records = [
+            (
+                MemoryRecord(
+                    is_reference=metadata["is_reference"],
+                    external_source_name=metadata["external_source_name"],
+                    id=metadata["id"],
+                    description=metadata["description"],
+                    text=document,
+                    embedding=embedding,
+                    additional_metadata=metadata["additional_metadata"],
+                    key=id,
+                    timestamp=metadata["timestamp"],
+                )
             )
-        )
-        for id, document, embedding, metadata in zip(
-            results["ids"][0],
-            results["documents"][0],
-            results["embeddings"][0],
-            results["metadatas"][0],
-        )
-    ]
+            for id, document, embedding, metadata in zip(
+                results["ids"][0],
+                results["documents"][0],
+                results["embeddings"][0],
+                results["metadatas"][0],
+            )
+        ]
+    else:
+        memory_records = [
+            (
+                MemoryRecord(
+                    is_reference=metadata["is_reference"],
+                    external_source_name=metadata["external_source_name"],
+                    id=metadata["id"],
+                    description=metadata["description"],
+                    text=document,
+                    embedding=None,
+                    additional_metadata=metadata["additional_metadata"],
+                    key=id,
+                    timestamp=metadata["timestamp"],
+                )
+            )
+            for id, document, metadata in zip(
+                results["ids"][0],
+                results["documents"][0],
+                results["metadatas"][0],
+            )
+        ]
     return memory_records
 
 

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/memory/pinecone/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.memory.pinecone.pinecone_memory_store import (
+    PineconeMemoryStore,
+)
+
+__all__ = ["PineconeMemoryStore"]