langroid 0.30.1__py3-none-any.whl → 0.31.1__py3-none-any.whl

langroid/agent/chat_agent.py

@@ -450,17 +450,23 @@ class ChatAgent(Agent):
             return ""
         instructions = []
         for msg_cls in enabled_classes:
-            if (
-                hasattr(msg_cls, "instructions")
-                and inspect.ismethod(msg_cls.instructions)
-                and msg_cls.default_value("request") in self.llm_tools_usable
-            ):
+            if msg_cls.default_value("request") in self.llm_tools_usable:
+                class_instructions = ""
+                if hasattr(msg_cls, "instructions") and inspect.ismethod(
+                    msg_cls.instructions
+                ):
+                    class_instructions = msg_cls.instructions()
+                if (
+                    self.config.use_tools
+                    and hasattr(msg_cls, "langroid_tools_instructions")
+                    and inspect.ismethod(msg_cls.langroid_tools_instructions)
+                ):
+                    class_instructions += msg_cls.langroid_tools_instructions()
                 # example will be shown in tool_format_rules() when using TOOLs,
                 # so we don't need to show it here.
                 example = "" if self.config.use_tools else (msg_cls.usage_examples())
                 if example != "":
                     example = "EXAMPLES:\n" + example
-                class_instructions = msg_cls.instructions()
                 guidance = (
                     ""
                     if class_instructions == ""

langroid/agent/tool_message.py

@@ -126,6 +126,18 @@ class ToolMessage(ABC, BaseModel):
 
     @classmethod
     def instructions(cls) -> str:
+        """
+        Instructions on tool usage.
+        """
+        return ""
+
+    @classmethod
+    def langroid_tools_instructions(cls) -> str:
+        """
+        Instructions on tool usage when `use_tools == True`, i.e.
+        when using langroid built-in tools
+        (as opposed to OpenAI-like function calls/tools).
+        """
         return """
         IMPORTANT: When using this or any other tool/function, you MUST include a 
         `request` field and set it equal to the FUNCTION/TOOL NAME you intend to use.

langroid/embedding_models/base.py

@@ -24,6 +24,8 @@ class EmbeddingModel(ABC):
     @classmethod
     def create(cls, config: EmbeddingModelsConfig) -> "EmbeddingModel":
         from langroid.embedding_models.models import (
+            AzureOpenAIEmbeddings,
+            AzureOpenAIEmbeddingsConfig,
             FastEmbedEmbeddings,
             FastEmbedEmbeddingsConfig,
             LlamaCppServerEmbeddings,
@@ -42,6 +44,8 @@ class EmbeddingModel(ABC):
             return RemoteEmbeddings(config)
         elif isinstance(config, OpenAIEmbeddingsConfig):
             return OpenAIEmbeddings(config)
+        elif isinstance(config, AzureOpenAIEmbeddingsConfig):
+            return AzureOpenAIEmbeddings(config)
         elif isinstance(config, SentenceTransformerEmbeddingsConfig):
             return SentenceTransformerEmbeddings(config)
         elif isinstance(config, FastEmbedEmbeddingsConfig):

langroid/embedding_models/models.py

@@ -6,13 +6,15 @@ from typing import Any, Callable, Dict, List, Optional
 import requests
 import tiktoken
 from dotenv import load_dotenv
-from openai import OpenAI
+from openai import AzureOpenAI, OpenAI
 
 from langroid.embedding_models.base import EmbeddingModel, EmbeddingModelsConfig
 from langroid.exceptions import LangroidImportError
 from langroid.mytypes import Embeddings
 from langroid.parsing.utils import batched
 
+AzureADTokenProvider = Callable[[], str]
+
 
 class OpenAIEmbeddingsConfig(EmbeddingModelsConfig):
     model_type: str = "openai"
@@ -24,6 +26,26 @@ class OpenAIEmbeddingsConfig(EmbeddingModelsConfig):
     context_length: int = 8192
 
 
+class AzureOpenAIEmbeddingsConfig(EmbeddingModelsConfig):
+    model_type: str = "azure-openai"
+    model_name: str = "text-embedding-ada-002"
+    api_key: str = ""
+    api_base: str = ""
+    deployment_name: Optional[str] = None
+    # api_version defaulted to 2024-06-01 as per https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/embeddings?tabs=python-new
+    # change this to required  supported version
+    api_version: Optional[str] = "2024-06-01"
+    # TODO: Add auth support for Azure OpenAI via AzureADTokenProvider
+    azure_ad_token: Optional[str] = None
+    azure_ad_token_provider: Optional[AzureADTokenProvider] = None
+    dims: int = 1536
+    context_length: int = 8192
+
+    class Config:
+        # enable auto-loading of env vars with AZURE_OPENAI_ prefix
+        env_prefix = "AZURE_OPENAI_"
+
+
 class SentenceTransformerEmbeddingsConfig(EmbeddingModelsConfig):
     model_type: str = "sentence-transformer"
     model_name: str = "BAAI/bge-large-en-v1.5"
@@ -58,11 +80,11 @@ class LlamaCppServerEmbeddingsConfig(EmbeddingModelsConfig):
 class EmbeddingFunctionCallable:
     """
     A callable class designed to generate embeddings for a list of texts using
-    the OpenAI API, with automatic retries on failure.
+    the OpenAI or Azure OpenAI API, with automatic retries on failure.
 
     Attributes:
         embed_model (EmbeddingModel): An instance of EmbeddingModel that provides
-                                configuration and utilities for generating embeddings.
+               configuration and utilities for generating embeddings.
 
     Methods:
         __call__(input: List[str]) -> Embeddings: Generate embeddings for
@@ -74,8 +96,9 @@ class EmbeddingFunctionCallable:
         Initialize the EmbeddingFunctionCallable with a specific model.
 
         Args:
-            model (OpenAIEmbeddings): An instance of OpenAIEmbeddings to use for
-            generating embeddings.
+            model ( OpenAIEmbeddings or AzureOpenAIEmbeddings): An instance of
+                            OpenAIEmbeddings or AzureOpenAIEmbeddings to use for
+                            generating embeddings.
             batch_size (int): Batch size
         """
         self.embed_model = embed_model
@@ -99,8 +122,7 @@ class EmbeddingFunctionCallable:
             Embeddings: A list of embedding vectors corresponding to the input texts.
         """
         embeds = []
-
-        if isinstance(self.embed_model, OpenAIEmbeddings):
+        if isinstance(self.embed_model, (OpenAIEmbeddings, AzureOpenAIEmbeddings)):
             tokenized_texts = self.embed_model.truncate_texts(input)
 
             for batch in batched(tokenized_texts, self.batch_size):
@@ -178,6 +200,72 @@ class OpenAIEmbeddings(EmbeddingModel):
         return self.config.dims
 
 
+class AzureOpenAIEmbeddings(EmbeddingModel):
+    """
+    Azure OpenAI embeddings model implementation.
+    """
+
+    def __init__(
+        self, config: AzureOpenAIEmbeddingsConfig = AzureOpenAIEmbeddingsConfig()
+    ):
+        """
+        Initializes Azure OpenAI embeddings model.
+
+        Args:
+            config: Configuration for Azure OpenAI embeddings model.
+        Raises:
+            ValueError: If required Azure config values are not set.
+        """
+        super().__init__()
+        self.config = config
+        load_dotenv()
+
+        if self.config.api_key == "":
+            raise ValueError(
+                """AZURE_OPENAI_API_KEY env variable must be set to use 
+            AzureOpenAIEmbeddings. Please set the AZURE_OPENAI_API_KEY value 
+            in your .env file."""
+            )
+
+        if self.config.api_base == "":
+            raise ValueError(
+                """AZURE_OPENAI_API_BASE env variable must be set to use 
+            AzureOpenAIEmbeddings. Please set the AZURE_OPENAI_API_BASE value 
+            in your .env file."""
+            )
+        self.client = AzureOpenAI(
+            api_key=self.config.api_key,
+            api_version=self.config.api_version,
+            azure_endpoint=self.config.api_base,
+            azure_deployment=self.config.deployment_name,
+        )
+        self.tokenizer = tiktoken.encoding_for_model(self.config.model_name)
+
+    def truncate_texts(self, texts: List[str]) -> List[List[int]]:
+        """
+        Truncate texts to the embedding model's context length.
+        TODO: Maybe we should show warning, and consider doing T5 summarization?
+        """
+        return [
+            self.tokenizer.encode(text, disallowed_special=())[
+                : self.config.context_length
+            ]
+            for text in texts
+        ]
+
+    def embedding_fn(self) -> Callable[[List[str]], Embeddings]:
+        """Get the embedding function for Azure OpenAI.
+
+        Returns:
+            Callable that generates embeddings for input texts.
+        """
+        return EmbeddingFunctionCallable(self, self.config.batch_size)
+
+    @property
+    def embedding_dims(self) -> int:
+        return self.config.dims
+
+
 STEC = SentenceTransformerEmbeddingsConfig
 
 
@@ -352,13 +440,19 @@ class LlamaCppServerEmbeddings(EmbeddingModel):
 def embedding_model(embedding_fn_type: str = "openai") -> EmbeddingModel:
     """
     Args:
-        embedding_fn_type: "openai" or "fastembed" or
-                           "llamacppserver" or "sentencetransformer" # others soon
+        embedding_fn_type: Type of embedding model to use. Options are:
+         - "openai",
+         - "azure-openai",
+         - "sentencetransformer", or
+         - "fastembed".
+            (others may be added in the future)
     Returns:
-        EmbeddingModel
+        EmbeddingModel: The corresponding embedding model class.
     """
     if embedding_fn_type == "openai":
         return OpenAIEmbeddings  # type: ignore
+    elif embedding_fn_type == "azure-openai":
+        return AzureOpenAIEmbeddings  # type: ignore
     elif embedding_fn_type == "fastembed":
         return FastEmbedEmbeddings  # type: ignore
     elif embedding_fn_type == "llamacppserver":

langroid/experimental/team-save.py

@@ -0,0 +1,391 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, List, Optional, Union
+
+import langroid as lr
+from langroid.language_models.mock_lm import MockLMConfig
+
+# Fix logging level type
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+
+def sum_fn(s: str) -> str:
+    """Dummy response for MockLM"""
+    nums = [
+        int(subpart)
+        for part in s.split()
+        for subpart in part.split(",")
+        if subpart.isdigit()
+    ]
+    return str(sum(nums) + 1)
+
+
+def user_message(msg: Union[str, lr.ChatDocument]) -> lr.ChatDocument:
+    """Create a user-role msg from a string or ChatDocument"""
+    if isinstance(msg, lr.ChatDocument):
+        return msg
+    return lr.ChatDocument(
+        content=msg,
+        metadata=lr.ChatDocMetaData(
+            sender=lr.Entity.USER,
+            sender_name="user",
+        ),
+    )
+
+
+class InputContext:
+    """Context for a Component to respond to"""
+
+    def __init__(self) -> None:
+        self.messages: List[lr.ChatDocument] = []
+
+    def add(
+        self, results: Union[str, List[str], lr.ChatDocument, List[lr.ChatDocument]]
+    ) -> None:
+        """
+        Add messages to the input messages list
+        """
+        msgs: List[lr.ChatDocument] = []
+        if isinstance(results, str):
+            msgs = [user_message(results)]
+        elif isinstance(results, lr.ChatDocument):
+            msgs = [results]
+        elif isinstance(results, list):
+            if len(results) == 0:
+                return
+            if isinstance(results[0], str):
+                msgs = [user_message(r) for r in results]
+            else:
+                msgs = [r for r in results if isinstance(r, lr.ChatDocument)]
+        self.messages.extend(msgs)
+
+    def clear(self) -> None:
+        self.messages.clear()
+
+    def get_context(self) -> lr.ChatDocument:
+        """Construct a user-role ChatDocument from the input messages"""
+        if len(self.messages) == 0:
+            return lr.ChatDocument(content="", metadata={"sender": lr.Entity.USER})
+        content = "\n".join(
+            f"{msg.metadata.sender_name}: {msg.content}" for msg in self.messages
+        )
+        return lr.ChatDocument(content=content, metadata={"sender": lr.Entity.USER})
+
+
+class Scheduler(ABC):
+    """Schedule the Components of a Team"""
+
+    def __init__(self) -> None:
+        self.init_state()
+
+    def init_state(self) -> None:
+        self.stepped = False
+        self.responders: List[str] = []
+        self.responder_counts: Dict[str, int] = {}
+        self.current_result: List[lr.ChatDocument] = []
+
+    @abstractmethod
+    def step(self) -> None:
+        pass
+
+    @abstractmethod
+    def done(self) -> bool:
+        pass
+
+    @abstractmethod
+    def result(self) -> List[lr.ChatDocument]:
+        pass
+
+    def run(self) -> List[lr.ChatDocument]:
+        self.init_state()
+        while not self.done():
+            self.step()
+        return self.result()
+
+
+class Component(ABC):
+    """A component of a Team"""
+
+    def __init__(self) -> None:
+        self.input = InputContext()
+        self._listeners: List["Component"] = []
+        self.name: str = ""
+
+    @abstractmethod
+    def run(self) -> List[lr.ChatDocument]:
+        pass
+
+    def listen(self, component: Union["Component", List["Component"]]) -> None:
+        if isinstance(component, list):
+            for comp in component:
+                comp.listeners.append(self)
+        else:
+            component.listeners.append(self)
+
+    @property
+    def listeners(self) -> List["Component"]:
+        return self._listeners
+
+    def _notify(self, results: List[lr.ChatDocument]) -> None:
+        logger.warning(f"{self.name} Notifying listeners...")
+        for listener in self.listeners:
+            logger.warning(f"--> Listener {listener.name} notified")
+            listener.input.add(results)
+
+
+class SimpleScheduler(Scheduler):
+    def __init__(
+        self,
+        components: List[Component],
+    ) -> None:
+        super().__init__()
+        self.components = components  # Get components from team
+        self.stepped: bool = False
+
+    def step(self) -> None:
+        results = []
+        for comp in self.components:
+            result = comp.run()
+            if result:
+                results.extend(result)
+        self.current_result = results
+        self.stepped = True
+
+    def done(self) -> bool:
+        """done after 1 step, i.e. all components have responded"""
+        return self.stepped
+
+    def result(self) -> List[lr.ChatDocument]:
+        return self.current_result
+
+
+class OrElseScheduler(Scheduler):
+    """
+    Implements "OrElse scheduling", i.e. if the components are A, B, C, then
+    in each step, it will try for a valid response from A OrElse B OrElse C,
+    i.e. the first component that gives a valid response is chosen.
+    In the next step, it will start from the next component in the list,
+    cycling back to the first component after the last component.
+    (There may be a better name than OrElseScheduler though.)
+    """
+
+    def __init__(
+        self,
+        components: List[Component],
+    ) -> None:
+        super().__init__()
+        self.components = components
+        self.team: Optional[Team] = None
+        self.current_index: int = 0
+
+    def init_state(self) -> None:
+        super().init_state()
+        self.current_index = 0
+
+    def is_valid(self, result: Optional[List[lr.ChatDocument]]) -> bool:
+        return result is not None and len(result) > 0
+
+    def step(self) -> None:
+        start_index = self.current_index
+        n = len(self.components)
+
+        for i in range(n):
+            idx = (start_index + i) % n
+            comp = self.components[idx]
+            result = comp.run()
+            if self.is_valid(result):
+                self.responders.append(comp.name)
+                self.responder_counts[comp.name] = (
+                    self.responder_counts.get(comp.name, 0) + 1
+                )
+                self.current_result = result
+                # cycle to next component
+                self.current_index = (idx + 1) % n
+                return
+
+    def done(self) -> bool:
+        if self.team is None:
+            return False
+        return self.team.done(self)
+
+    def result(self) -> List[lr.ChatDocument]:
+        return self.current_result
+
+
+class Team(Component):
+    def __init__(
+        self,
+        name: str,
+        done_condition: Optional[Callable[["Team", Scheduler], bool]] = None,
+    ) -> None:
+        super().__init__()
+        self.name = name
+        self.components: List[Component] = []
+        self.scheduler: Optional[Scheduler] = None
+        self.done_condition = done_condition or Team.default_done_condition
+
+    def set_done_condition(
+        self, done_condition: Callable[["Team", Scheduler], bool]
+    ) -> None:
+        self.done_condition = done_condition
+
+    def done(self, scheduler: Scheduler) -> bool:
+        return self.done_condition(self, scheduler)
+
+    def default_done_condition(self, scheduler: Scheduler) -> bool:
+        # Default condition, can be overridden
+        return False
+
+    def add_scheduler(self, scheduler_class: type) -> None:
+        self.scheduler = scheduler_class(self.components)
+        if hasattr(self.scheduler, "team"):
+            setattr(self.scheduler, "team", self)
+
+    def add(self, component: Union[Component, List[Component]]) -> None:
+        if isinstance(component, list):
+            self.components.extend(component)
+        else:
+            self.components.append(component)
+
+    def reset(self) -> None:
+        self.input.clear()
+        if self.scheduler is not None:
+            self.scheduler.init_state()
+
+    def run(self, input: str | lr.ChatDocument | None = None) -> List[lr.ChatDocument]:
+        if input is not None:
+            self.input.add(input)
+        if self.scheduler is None:
+            raise ValueError(
+                f"Team '{self.name}' has no scheduler. Call add_scheduler() first."
+            )
+        input_str = self.input.get_context().content
+        logger.warning(f"Running team {self.name}... on input = {input_str}")
+        # push the input of self to each component that's a listener of self.
+        n_pushed = 0
+        for comp in self.components:
+
+            if comp in self.listeners:
+                comp.input.add(self.input.messages)
+                n_pushed += 1
+        if len(self.input.messages) > 0 and n_pushed == 0:
+            logger.warning(
+                """
+                Warning: Team inputs not pushed to any components!
+                You may not be able to run any components unless they have their
+                own inputs. Make sure to set up component to listen to parent team
+                if needed.
+                """
+            )
+        # clear own input since we've pushed it to internal components
+        self.input.clear()
+
+        result = self.scheduler.run()
+        if len(result) > 0:
+            self._notify(result)
+        result_value = result[0].content if len(result) > 0 else "null"
+        logger.warning(f"Team {self.name} done: {result_value}")
+        return result
+
+
+class DummyAgent:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def process(self, data: str) -> str:
+        return f"{self.name} processed: {data}"
+
+
+class TaskComponent(Component):
+    def __init__(self, task: lr.Task) -> None:
+        super().__init__()
+        self.task = task
+        self.name = task.agent.config.name
+
+    def run(self, input: str | lr.ChatDocument | None = None) -> List[lr.ChatDocument]:
+        if input is not None:
+            self.input.add(input)
+        input_msg = self.input.get_context()
+        if input_msg.content == "":
+            return []
+        logger.warning(f"Running task {self.name} on input = {input_msg.content}")
+        result = self.task.run(input_msg)
+        result_value = result.content if result else "null"
+        logger.warning(f"Task {self.name} done: {result_value}")
+        result_list = [result] if result else []
+        if len(result_list) > 0:
+            self._notify(result_list)
+            self.input.clear()  # clear own input since we just consumed it!
+        return result_list
+
+
+def make_task(name: str, sys: str = "") -> TaskComponent:
+    llm_config = MockLMConfig(response_fn=sum_fn)
+    agent = lr.ChatAgent(
+        lr.ChatAgentConfig(
+            llm=llm_config,
+            name=name,
+        )
+    )
+    # set as single_round since there are no Tools
+    task = lr.Task(agent, interactive=False, single_round=True)
+    return TaskComponent(task)
+
+
+if __name__ == "__main__":
+    # Create agents, tasks
+    t1 = make_task("a1")
+    t2 = make_task("a2")
+    t3 = make_task("a3")
+
+    # done conditions for each time
+    def team1_done_condition(team: Team, scheduler: Scheduler) -> bool:
+        return (
+            scheduler.responder_counts.get("a1", 0) >= 2
+            and scheduler.responder_counts.get("a2", 0) >= 2
+        )
+
+    def team2_done_condition(team: Team, scheduler: Scheduler) -> bool:
+        return "a3" in scheduler.responders
+
+    def general_team_done_condition(team: Team, scheduler: Scheduler) -> bool:
+        # Example: all components have responded at least once
+        return len(set(scheduler.responders)) == len(team.components)
+
+    # Create teams
+    team1 = Team("T1", done_condition=team1_done_condition)
+    team2 = Team("T2", done_condition=team2_done_condition)
+
+    team = Team("Team", done_condition=general_team_done_condition)
+
+    team1.add_scheduler(OrElseScheduler)
+    team2.add_scheduler(OrElseScheduler)
+    team.add_scheduler(OrElseScheduler)
+
+    team.add([team1, team2])
+
+    # Build hierarchy
+    team1.add([t1, t2])
+    team2.add(t3)
+
+    # Set up listening
+    # team2.listen(team1)  # listens to team1 final result
+    team1.listen(team)
+    t1.listen(team1)
+    t2.listen(t1)
+    t1.listen(t2)
+    # TODO should we forbid listening to a component OUTSIDE the team?
+
+    # t3 listens to its parent team2 =>
+    # any input to team2 gets pushed to t3 when t3 runs
+    team2.listen([t1, t2])
+    t3.listen(team2)
+
+    # TODO - we should either define which component of a team gets the teams inputs,
+    # or explicitly add messages to a specific component of the team
+
+    print("Running top-level team...")
+    result = team.run("1")
+
+    ##########

langroid/language_models/azure_openai.py

@@ -6,7 +6,6 @@ from httpx import Timeout
 from openai import AsyncAzureOpenAI, AzureOpenAI
 
 from langroid.language_models.openai_gpt import (
-    OpenAIChatModel,
     OpenAIGPT,
     OpenAIGPTConfig,
 )
@@ -32,11 +31,12 @@ class AzureConfig(OpenAIGPTConfig):
         deployment_name (str): can be set in the ``.env`` file as
             ``AZURE_OPENAI_DEPLOYMENT_NAME`` and should be based the custom name you
             chose for your deployment when you deployed a model.
-        model_name (str): can be set in the ``.env`` file as ``AZURE_GPT_MODEL_NAME``
+        model_name (str): can be set in the ``.env``
+            file as ``AZURE_OPENAI_MODEL_NAME``
             and should be based on the model name chosen during setup.
         model_version (str): can be set in the ``.env`` file as
-          ``AZURE_OPENAI_MODEL_VERSION`` and should be based on the model name
-          chosen during setup.
+            ``AZURE_OPENAI_MODEL_VERSION`` and should be based on the model name
+            chosen during setup.
     """
 
     api_key: str = ""  # CAUTION: set this ONLY via env var AZURE_OPENAI_API_KEY
@@ -145,70 +145,9 @@ class AzureGPT(OpenAIGPT):
             )
 
         # set the chat model to be the same as the model_name
-        # This corresponds to the gpt model you chose for your deployment
-        # when you deployed a model
-        self.set_chat_model()
+        self.config.chat_model = self.config.model_name
 
         self.supports_json_schema = (
             self.config.api_version >= azureStructuredOutputAPIMin
             and self.config.model_version in azureStructuredOutputList
         )
-
-    def set_chat_model(self) -> None:
-        """
-        Sets the chat model configuration based on the model name specified in the
-        ``.env``. This function checks the `model_name` in the configuration and sets
-        the appropriate chat model in the `config.chat_model`. It supports handling for
-        'gpt-35-turbo', 'gpt4-turbo', 'gpt-4o' and 'gpt-4o-mini' models. For
-        'gpt-4', it further delegates the handling to `handle_gpt4_model` method.
-        If the model name does not match any predefined models, it defaults to
-        `OpenAIChatModel.GPT4`.
-        """
-        MODEL_35_TURBO_NAMES = ("gpt-35-turbo", "35-turbo")
-        MODEL_GPT4_TURBO_NAME = "gpt-4-turbo"
-        MODEL_GPT4o_NAME = "gpt-4o"
-        MODEL_GPT4o_MINI_NAME = "gpt-4o-mini"
-        MODEL_GPT4_PREFIX = "gpt-4"
-
-        if self.config.model_name in MODEL_35_TURBO_NAMES:
-            self.config.chat_model = OpenAIChatModel.GPT3_5_TURBO
-        elif self.config.model_name == MODEL_GPT4o_NAME:
-            self.config.chat_model = OpenAIChatModel.GPT4o
-        elif self.config.model_name == MODEL_GPT4o_MINI_NAME:
-            self.config.chat_model = OpenAIChatModel.GPT4o_MINI
-        elif self.config.model_name == MODEL_GPT4_TURBO_NAME:
-            self.config.chat_model = OpenAIChatModel.GPT4_TURBO
-        elif isinstance(
-            self.config.model_name, str
-        ) and self.config.model_name.startswith(MODEL_GPT4_PREFIX):
-            self.handle_gpt4_model()
-        else:
-            self.config.chat_model = OpenAIChatModel.GPT4
-
-    def handle_gpt4_model(self) -> None:
-        """
-        Handles the setting of the GPT-4 model in the configuration.
-        This function checks the `model_version` in the configuration.
-        If the version is not set, it raises a ValueError indicating
-        that the model version needs to be specified in the ``.env``
-        file.  It sets `OpenAIChatMode.GPT4o` if the version is
-        one of those listed below, and
-        `OpenAIChatModel.GPT4_TURBO` if
-        the version is '1106-Preview', otherwise, it defaults to
-        setting `OpenAIChatModel.GPT4`.
-        """
-        VERSIONS_GPT4_TURBO = ("1106-Preview", "2024-04-09")
-        VERSIONS_GPT4o = ("2024-05-13", "2024-08-06", "2024-11-20")
-
-        if self.config.model_version == "":
-            raise ValueError(
-                "AZURE_OPENAI_MODEL_VERSION not set in .env file. "
-                "Please set it to the chat model version used in your deployment."
-            )
-
-        if self.config.model_version in VERSIONS_GPT4o:
-            self.config.chat_model = OpenAIChatModel.GPT4o
-        elif self.config.model_version in VERSIONS_GPT4_TURBO:
-            self.config.chat_model = OpenAIChatModel.GPT4_TURBO
-        else:
-            self.config.chat_model = OpenAIChatModel.GPT4

langroid/language_models/openai_gpt.py

@@ -1702,12 +1702,7 @@ class OpenAIGPT(LanguageModel):
                     ),
                 )
 
-        # Azure uses different parameters. It uses ``engine`` instead of ``model``
-        # and the value should be the deployment_name not ``self.config.chat_model``
         chat_model = self.config.chat_model
-        if self.config.type == "azure":
-            if hasattr(self, "deployment_name"):
-                chat_model = self.deployment_name
 
         args: Dict[str, Any] = dict(
             model=chat_model,

{langroid-0.30.1.dist-info → langroid-0.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.30.1
+Version: 0.31.1
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -249,6 +249,14 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Dec 2024:**
+  - [0.30.0](https://github.com/langroid/langroid/releases/tag/0.30.0) Llama-cpp embeddings.
+  - [0.29.0](https://github.com/langroid/langroid/releases/tag/0.29.0) Custom Azure OpenAI Client 
+  - [0.28.0](https://github.com/langroid/langroid/releases/tag/0.28.0) `ToolMessage`: `_handler` field to override 
+default handler method name in `request` field. 
+  - [0.27.0](https://github.com/langroid/langroid/releases/tag/0.27.0) OpenRouter Support.
+  - [0.26.0](https://github.com/langroid/langroid/releases/tag/0.26.0) Update to latest Chainlit.
+  - [0.25.0](https://github.com/langroid/langroid/releases/tag/0.25.0) True Async Methods for agent and user-response.
 - **Nov 2024:**
   - **[0.24.0](https://langroid.github.io/langroid/notes/structured-output/)**: 
      Enables support for `Agent`s with strict JSON schema output format on compatible LLMs and strict mode for the OpenAI tools API.

{langroid-0.30.1.dist-info → langroid-0.31.1.dist-info}/RECORD

@@ -16,7 +16,7 @@ langroid/agent/base.py,sha256=ZgWsRBC9rugcWp9aZLAmFFteU47pqKIEoTy_dgkYtBI,77529
 langroid/agent/batch.py,sha256=qK3ph6VNj_1sOhfXCZY4r6gh035DglDKU751p8BU0tY,14665
 langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/callbacks/chainlit.py,sha256=C6zzzYC30qC4eMA7al7eFpRoTgoe3475kaMKyXgQM0Q,20695
-langroid/agent/chat_agent.py,sha256=qPo-avgv4ng7f3vdU4kCbQHLtSTpT2U8XRZbmE0uVKo,79684
+langroid/agent/chat_agent.py,sha256=Idts_HDO1tW052POVOQ9FvuU37TTB7c1I96YVbnBumo,80030
 langroid/agent/chat_document.py,sha256=xPUMGzR83rn4iAEXIw2jy5LQ6YJ6Y0TiZ78XRQeDnJQ,17778
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
@@ -51,7 +51,7 @@ langroid/agent/special/sql/utils/tools.py,sha256=ovCePzq5cmbqw0vsVPBzxdZpUcSUIfT
 langroid/agent/special/table_chat_agent.py,sha256=d9v2wsblaRx7oMnKhLV7uO_ujvk9gh59pSGvBXyeyNc,9659
 langroid/agent/structured_message.py,sha256=y7pud1EgRNeTFZlJmBkLmwME3yQJ_IYik-Xds9kdZbY,282
 langroid/agent/task.py,sha256=_iQTpjPIR1OGF0lq-ZFzQ92f_OmdIFmv7LlhoUA1QB8,89729
-langroid/agent/tool_message.py,sha256=aaJSypRy2sC8b2qOszc7efgr5TrQva51SUGnxTwKXEg,14406
+langroid/agent/tool_message.py,sha256=HDW_FVQXvZAHI61CtOYNuZet0qlK_WwOnjSYd1g81eo,14742
 langroid/agent/tools/__init__.py,sha256=IMgCte-_ZIvCkozGQmvMqxIw7_nKLKzD78ccJL1bnQU,804
 langroid/agent/tools/duckduckgo_search_tool.py,sha256=NhsCaGZkdv28nja7yveAhSK_w6l_Ftym8agbrdzqgfo,1935
 langroid/agent/tools/file_tools.py,sha256=GjPB5YDILucYapElnvvoYpGJuZQ25ecLs2REv7edPEo,7292
@@ -70,9 +70,9 @@ langroid/cachedb/base.py,sha256=ztVjB1DtN6pLCujCWnR6xruHxwVj3XkYniRTYAKKqk0,1354
 langroid/cachedb/momento_cachedb.py,sha256=YEOJ62hEcV6iIeMr5aGgRYgWQqFYaej9gEDEcY0sm7M,3172
 langroid/cachedb/redis_cachedb.py,sha256=7kgnbf4b5CKsCrlL97mHWKvdvlLt8zgn7lc528jEpiE,5141
 langroid/embedding_models/__init__.py,sha256=XhVIMQJbQRpImcnhA9sJR7h6r7QgPo1SKDCvwEUD9j4,851
-langroid/embedding_models/base.py,sha256=Ipk6LcBZSmbu8HzfQy6uSp6-xAWCrmzX3MzhOr-jCZI,2208
+langroid/embedding_models/base.py,sha256=DUhvzALoW2UMbtmLxP4eJTfPii99WjUNX7bwFpj_K-0,2395
 langroid/embedding_models/clustering.py,sha256=tZWElUqXl9Etqla0FAa7og96iDKgjqWjucZR_Egtp-A,6684
-langroid/embedding_models/models.py,sha256=pDED-Evwz3Y9tCwo2amOJVIIT0P9uskcbhs6gz6wVcU,13358
+langroid/embedding_models/models.py,sha256=sW6baTvFSeZBZ5w-Kd9Vgo93gokesJ3aHP4x9htoF2E,16776
 langroid/embedding_models/protoc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/embedding_models/protoc/embeddings.proto,sha256=_O-SgFpTaylQeOTgSpxhEJ7CUw7PeCQQJLaPqpPYKJg,321
 langroid/embedding_models/protoc/embeddings_pb2.py,sha256=4Q57PhOunv-uZNJrxYrWBXAI0ZtfnVZXFRhRj5JuRSg,1662
@@ -80,14 +80,15 @@ langroid/embedding_models/protoc/embeddings_pb2.pyi,sha256=UkNy7BrNsmQm0vLb3NtGX
 langroid/embedding_models/protoc/embeddings_pb2_grpc.py,sha256=9dYQqkW3JPyBpSEjeGXTNpSqAkC-6FPtBHyteVob2Y8,2452
 langroid/embedding_models/remote_embeds.py,sha256=6_kjXByVbqhY9cGwl9R83ZcYC2km-nGieNNAo1McHaY,5151
 langroid/exceptions.py,sha256=G60UVDChkUlBDVWHFr_43zUUszZHSejoU00tX_dfD68,2322
+langroid/experimental/team-save.py,sha256=OHfACxuVMFNiU0Kx0uCClimJCyusZineMDJ0Ehh2jWM,12369
 langroid/language_models/.chainlit/config.toml,sha256=1t5lHORGzc2E6dkaO9P15jYHu2w-4Kl9pYjpDPc84vs,3716
 langroid/language_models/.chainlit/translations/en-US.json,sha256=DAFz2HjOFFfboCStrUfKFg2BpplJPK_OOtixwF_GivY,9931
 langroid/language_models/__init__.py,sha256=8o8D8Lxaq961_oxVpB_bC2iEJ1GXJqYXMlwUcn6OJb8,976
-langroid/language_models/azure_openai.py,sha256=0a86-EtjgRsYw9kuGv0Tu6EOFbTCc-d5kb3GCJaJA54,8757
+langroid/language_models/azure_openai.py,sha256=zNQzzsERxNestq-hFfQZbvTzK43G2vjRWnTV3ktm1DQ,5845
 langroid/language_models/base.py,sha256=6hXR-bclyPif-BvFbyXevP-gEwiawQAJHX3N1AKNei0,23786
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
 langroid/language_models/mock_lm.py,sha256=5BgHKDVRWFbUwDT_PFgTZXz9-k8wJSA2e3PZmyDgQ1k,4022
-langroid/language_models/openai_gpt.py,sha256=mKlsSLxG835S2rvq9uNtapeutqvoM4A33mL3ywvRfDU,75627
+langroid/language_models/openai_gpt.py,sha256=gkF3sQsBrS8_x4x0l6GLdF_5MlNRdsY5hAmRPSsKAKE,75320
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
 langroid/language_models/prompt_formatter/hf_formatter.py,sha256=PVJppmjRvD-2DF-XNC6mE05vTZ9wbu37SmXwZBQhad0,5055
@@ -154,8 +155,8 @@ langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3Hmh
 langroid/vector_store/momento.py,sha256=UNHGT6jXuQtqY9f6MdqGU14bVnS0zHgIJUa30ULpUJo,10474
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=v7mCsijc2GdRJyil-yFaUVAX4SX5D75mD3vzlpjCMuo,17393
-pyproject.toml,sha256=2C5IMt-RiukUCIxH4Zyrp6LDWer61y0IkfW3SN2Wfj0,7533
-langroid-0.30.1.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.30.1.dist-info/METADATA,sha256=AJeOXFsiRYLBPiNiWtMCS8JVdnHBRC7oKDIjpycQs2I,57569
-langroid-0.30.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-langroid-0.30.1.dist-info/RECORD,,
+pyproject.toml,sha256=4LnvkHuotknbr-AsiwehYqKmmVSs_Xi7bYBbOf0E6X0,7525
+langroid-0.31.1.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.31.1.dist-info/METADATA,sha256=g593rbues9sKvoTGX88_zLbVE5DqIxvo-ZkmamSnJt8,58250
+langroid-0.31.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+langroid-0.31.1.dist-info/RECORD,,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.30.1"
+version = "0.31.1"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -155,7 +155,7 @@ fastembed = ["fastembed"]
 black = {extras = ["jupyter"], version = "^24.3.0"}
 flake8 = "^6.0.0"
 mypy = "^1.11.2"
-ruff = "^0.2.2"
+ruff = "^0.8.4"
 pre-commit = "^3.3.2"
 autopep8 = "^2.0.2"
 
@@ -211,10 +211,10 @@ python_version = "3.11"
 #mypy_path = ["stubs"]
 
 #follow_imports = "skip"
-#check_untyped_defs = "True"
-disallow_untyped_defs = "True"
-ignore_missing_imports = "True"
-warn_unused_ignores = "False"
+#check_untyped_defs = true
+disallow_untyped_defs = true
+ignore_missing_imports = true
+warn_unused_ignores = false
 strict = true
 exclude = [
     "docs", ".venv", "venv", "examples", "examples_dev", "langroid/utils/web",