langroid 0.28.7__tar.gz → 0.29.0__tar.gz

{langroid-0.28.7 → langroid-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.28.7
+Version: 0.29.0
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani

langroid-0.29.0/langroid/agent/team.py

@@ -0,0 +1,186 @@
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+import langroid as lr
+from langroid import ChatDocument
+
+
+class InputContext:
+    def __init__(self):
+        self.messages: List[lr.ChatDocument] = []
+
+    def add(self, results: List[lr.ChatDocument]):
+        self.messages.extend(results)
+
+    def clear(self):
+        self.messages.clear()
+
+
+class Scheduler(ABC):
+    @abstractmethod
+    def step(self) -> None:
+        pass
+
+    @abstractmethod
+    def done(self) -> bool:
+        pass
+
+    @abstractmethod
+    def result(self) -> lr.ChatDocument:
+        pass
+
+    def run(self):
+        while not self.done():
+            self.step()
+        return self.result()
+
+
+class Component(ABC):
+    def __init__(self):
+        self.input = InputContext()
+
+    @abstractmethod
+    def run(self, inputs: List[Any]) -> Any:
+        pass
+
+    def listen(self, component: Component | List[Component]):
+        if isinstance(component, list):
+            for comp in component:
+                comp.listeners.append(self)
+        else:
+            component.listeners.append(self)
+
+    @property
+    def listeners(self) -> List["Component"]:
+        if not hasattr(self, "_listeners"):
+            self._listeners = []
+        return self._listeners
+
+
+class SimpleScheduler(Scheduler):
+    def __init__(
+        self, components: List[Component], inputs: List[lr.ChatDocument] = None
+    ):
+        self.components: List[Component] = components
+        self.inputs: List[lr.ChatDocument] = inputs or []
+        self.current_results: List[lr.ChatDocument] = []
+        self.stepped: bool = False
+
+    def step(self):
+        self.current_results = [comp.run(self.inputs) for comp in self.components]
+        self.stepped = True
+
+    def done(self):
+        return self.stepped  # Now returns True only after stepping
+
+    def result(self):
+        return self.current_results
+
+
+class OrElseScheduler(Scheduler):
+    def __init__(self, components, inputs=None):
+        self.components = components
+        self.inputs = inputs or []
+        self.current_result = None
+        self.done_flag = False
+
+    def is_valid(self, result) -> bool:
+        return result is not None and result != ""
+
+    def step(self):
+        for comp in self.components:
+            result = comp.run(comp.input.messages)
+            if self.is_valid(result):
+                self.current_result = result
+                self.done_flag = True
+                return
+        self.done_flag = True
+
+    def done(self):
+        return self.done_flag
+
+    def result(self):
+        return self.current_result
+
+
+class Team(Component):
+    def __init__(self, name: str, scheduler_class=SimpleScheduler):
+        super().__init__()
+        self.name = name
+        self.components = []
+        self.scheduler_class = scheduler_class
+
+    def add(self, component: Union[Component, List[Component]]):
+        if isinstance(component, list):
+            self.components.extend(component)
+        else:
+            self.components.append(component)
+
+    def listen(self, team: "Team"):
+        # TODO Can a team listen to a component outside of itself?
+        team.listeners.append(self)
+
+    def run(self, inputs=None) -> Any:
+        all_inputs = inputs or self.input.messages
+        scheduler = self.scheduler_class(self.components, inputs=all_inputs)
+        result = scheduler.run()
+        self._notify(result)
+        self.input.clear()
+        return result
+
+    def _notify(self, results: List[Any]):
+        for listener in self.listeners:
+            listener.input.add(results)
+
+
+# Example of existing agent class
+class DummyAgent:
+    def __init__(self, name):
+        self.name = name
+
+    def process(self, data):
+        return f"{self.name} processed: {data}"
+
+
+# Adapter for existing agent
+class AgentAdapter(Component):
+    def __init__(self, agent: DummyAgent):
+        super().__init__()
+        self.agent = agent
+
+    def run(self, inputs: List[Any]) -> str:
+        input_str = ", ".join(str(x) for x in inputs) if inputs else "no input"
+        return self.agent.process(input_str)
+
+
+if __name__ == "__main__":
+    # Create agents
+    agent1 = AgentAdapter(DummyAgent("Agent1"))
+    agent2 = AgentAdapter(DummyAgent("Agent2"))
+    agent3 = AgentAdapter(DummyAgent("Agent3"))
+
+    # Create teams
+    team1 = Team("Team1")
+    team2 = Team("Team2")
+
+    # Build hierarchy
+    team1.add([agent1, agent2])
+    team2.add(agent3)
+
+    # Set up listening
+    team2.listen(team1)
+    agent1.listen(agent2)
+    agent2.listen(agent1)
+
+    #TODO - who will orchestrate team1 + team2 ?
+    # Run scenarios
+    print("Running team1...")
+    result1 = team1.run(["Start discussion"])
+    print(f"Team1 result: {result1}")
+    print(f"Agent1's inputs: {agent1.input.messages}")
+    print(f"Agent2's inputs: {agent2.input.messages}")
+
+    print("\nRunning team2...")
+    result2 = team2.run()
+    print(f"Agent3's inputs from agent1: {agent3.input.messages}")
+    print(f"Team2 result: {result2}")

{langroid-0.28.7 → langroid-0.29.0}/langroid/language_models/azure_openai.py

@@ -1,3 +1,6 @@
+import logging
+from typing import Callable
+
 from dotenv import load_dotenv
 from httpx import Timeout
 from openai import AsyncAzureOpenAI, AzureOpenAI
@@ -15,6 +18,8 @@ azureStructuredOutputList = [
 
 azureStructuredOutputAPIMin = "2024-08-01-preview"
 
+logger = logging.getLogger(__name__)
+
 
 class AzureConfig(OpenAIGPTConfig):
     """
@@ -42,6 +47,10 @@ class AzureConfig(OpenAIGPTConfig):
     model_version: str = ""  # is used to determine the cost of using the model
     api_base: str = ""
 
+    # Alternatively, bring your own clients:
+    azure_openai_client_provider: Callable[[], AzureOpenAI] | None = None
+    azure_openai_async_client_provider: Callable[[], AsyncAzureOpenAI] | None = None
+
     # all of the vars above can be set via env vars,
     # by upper-casing the name and prefixing with `env_prefix`, e.g.
     # AZURE_OPENAI_API_VERSION=2023-05-15
@@ -69,20 +78,6 @@ class AzureGPT(OpenAIGPT):
         load_dotenv()
         super().__init__(config)
         self.config: AzureConfig = config
-        if self.config.api_key == "":
-            raise ValueError(
-                """
-                AZURE_OPENAI_API_KEY not set in .env file,
-                please set it to your Azure API key."""
-            )
-
-        if self.config.api_base == "":
-            raise ValueError(
-                """
-                AZURE_OPENAI_API_BASE not set in .env file,
-                please set it to your Azure API key."""
-            )
-
         if self.config.deployment_name == "":
             raise ValueError(
                 """
@@ -98,6 +93,57 @@ class AzureGPT(OpenAIGPT):
                 please set it to chat model name in your deployment."""
             )
 
+        if (
+            self.config.azure_openai_client_provider
+            or self.config.azure_openai_async_client_provider
+        ):
+            if not self.config.azure_openai_client_provider:
+                self.client = None
+                logger.warning(
+                    "Using user-provided Azure OpenAI client, but only async "
+                    "client has been provided. Synchronous calls will fail."
+                )
+            if not self.config.azure_openai_async_client_provider:
+                self.async_client = None
+                logger.warning(
+                    "Using user-provided Azure OpenAI client, but no async "
+                    "client has been provided. Asynchronous calls will fail."
+                )
+
+            if self.config.azure_openai_client_provider:
+                self.client = self.config.azure_openai_client_provider()
+            if self.config.azure_openai_async_client_provider:
+                self.async_client = self.config.azure_openai_async_client_provider()
+                self.async_client.timeout = Timeout(self.config.timeout)
+        else:
+            if self.config.api_key == "":
+                raise ValueError(
+                    """
+                    AZURE_OPENAI_API_KEY not set in .env file,
+                    please set it to your Azure API key."""
+                )
+
+            if self.config.api_base == "":
+                raise ValueError(
+                    """
+                    AZURE_OPENAI_API_BASE not set in .env file,
+                    please set it to your Azure API key."""
+                )
+
+            self.client = AzureOpenAI(
+                api_key=self.config.api_key,
+                azure_endpoint=self.config.api_base,
+                api_version=self.config.api_version,
+                azure_deployment=self.config.deployment_name,
+            )
+            self.async_client = AsyncAzureOpenAI(
+                api_key=self.config.api_key,
+                azure_endpoint=self.config.api_base,
+                api_version=self.config.api_version,
+                azure_deployment=self.config.deployment_name,
+                timeout=Timeout(self.config.timeout),
+            )
+
         # 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
@@ -108,20 +154,6 @@ class AzureGPT(OpenAIGPT):
             and self.config.model_version in azureStructuredOutputList
         )
 
-        self.client = AzureOpenAI(
-            api_key=self.config.api_key,
-            azure_endpoint=self.config.api_base,
-            api_version=self.config.api_version,
-            azure_deployment=self.config.deployment_name,
-        )
-        self.async_client = AsyncAzureOpenAI(
-            api_key=self.config.api_key,
-            azure_endpoint=self.config.api_base,
-            api_version=self.config.api_version,
-            azure_deployment=self.config.deployment_name,
-            timeout=Timeout(self.config.timeout),
-        )
-
     def set_chat_model(self) -> None:
         """
         Sets the chat model configuration based on the model name specified in the

{langroid-0.28.7 → langroid-0.29.0}/langroid/language_models/openai_gpt.py

@@ -432,8 +432,8 @@ class OpenAIGPT(LanguageModel):
     Class for OpenAI LLMs
     """
 
-    client: OpenAI | Groq | Cerebras
-    async_client: AsyncOpenAI | AsyncGroq | AsyncCerebras
+    client: OpenAI | Groq | Cerebras | None
+    async_client: AsyncOpenAI | AsyncGroq | AsyncCerebras | None
 
     def __init__(self, config: OpenAIGPTConfig = OpenAIGPTConfig()):
         """
@@ -1375,12 +1375,15 @@ class OpenAIGPT(LanguageModel):
             else:
                 if self.config.litellm:
                     from litellm import completion as litellm_completion
-                assert isinstance(self.client, OpenAI)
-                completion_call = (
-                    litellm_completion
-                    if self.config.litellm
-                    else self.client.completions.create
-                )
+
+                    completion_call = litellm_completion
+                else:
+                    if self.client is None:
+                        raise ValueError(
+                            "OpenAI/equivalent chat-completion client not set"
+                        )
+                    assert isinstance(self.client, OpenAI)
+                    completion_call = self.client.completions.create
                 if self.config.litellm and settings.debug:
                     kwargs["logger_fn"] = litellm_logging_fn
                 # If it's not in the cache, call the API
@@ -1619,14 +1622,15 @@ class OpenAIGPT(LanguageModel):
             if settings.debug:
                 print("[grey37]CACHED[/grey37]")
         else:
+            # If it's not in the cache, call the API
             if self.config.litellm:
                 from litellm import completion as litellm_completion
-            # If it's not in the cache, call the API
-            completion_call = (
-                litellm_completion
-                if self.config.litellm
-                else self.client.chat.completions.create
-            )
+
+                completion_call = litellm_completion
+            else:
+                if self.client is None:
+                    raise ValueError("OpenAI/equivalent chat-completion client not set")
+                completion_call = self.client.chat.completions.create
             if self.config.litellm and settings.debug:
                 kwargs["logger_fn"] = litellm_logging_fn
             result = completion_call(**kwargs)
@@ -1649,11 +1653,14 @@ class OpenAIGPT(LanguageModel):
         else:
             if self.config.litellm:
                 from litellm import acompletion as litellm_acompletion
-            acompletion_call = (
-                litellm_acompletion
-                if self.config.litellm
-                else self.async_client.chat.completions.create
-            )
+
+                acompletion_call = litellm_acompletion
+            else:
+                if self.async_client is None:
+                    raise ValueError(
+                        "OpenAI/equivalent async chat-completion client not set"
+                    )
+                acompletion_call = self.async_client.chat.completions.create
             if self.config.litellm and settings.debug:
                 kwargs["logger_fn"] = litellm_logging_fn
             # If it's not in the cache, call the API

{langroid-0.28.7 → langroid-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.28.7"
+version = "0.29.0"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"

langroid-0.28.7/langroid/agent/team.py

@@ -1,41 +0,0 @@
-from abc import ABC, abstractmethod
-
-class TeamComponent(ABC):
-    @abstractmethod
-    def run(self, msg):
-        pass
-
-class Team(TeamComponent):
-    def __init__(self):
-        self.components = []
-        self.input_port = []
-        self.followers = []
-        self.scheduler = None
-
-    def follow(self, team):
-        team.followers.append(self)
-
-    def add_component(self, component):
-        self.components.append(component)
-
-    def notify_followers(self, result):
-        for follower in self.followers:
-            follower.input_port.append(result)
-
-    def run(self, msg):
-        if self.scheduler:
-            return self.scheduler.run(self.components, msg)
-        # Default sequential execution
-        result = ""
-        for component in self.components:
-            result += component.run(msg)
-        self.notify_followers(result)
-        return result
-
-class Agent(TeamComponent):
-    def __init__(self, name):
-        self.name = name
-
-    def run(self, msg):
-        result = f"Agent {self.name} processed: {msg}"
-        return result