example: multi-agent-debate lints

Author: pchalasani

examples/multi-agent-debate/config.py

@@ -1,4 +1,3 @@
-from rich.prompt import Prompt
 from typing import Optional
 import langroid.language_models as lm
 import langroid.utils.configuration
@@ -23,6 +22,7 @@
 
 MISTRAL_MAX_OUTPUT_TOKENS = 16_000
 
+
 def get_global_settings(debug: bool = False, nocache: bool = True) -> Settings:
     """
     Retrieve global Langroid settings.
@@ -40,7 +40,9 @@ def get_global_settings(debug: bool = False, nocache: bool = True) -> Settings:
     )
 
 
-def create_llm_config(chat_model_option: str, temperature: Optional[float] = None) -> OpenAIGPTConfig:
+def create_llm_config(
+    chat_model_option: str, temperature: Optional[float] = None
+) -> OpenAIGPTConfig:
     """
     Creates an LLM (Language Learning Model) configuration based on the selected model.
 
@@ -57,32 +59,41 @@ def create_llm_config(chat_model_option: str, temperature: Optional[float] = Non
     Raises:
         ValueError: If the user provided`chat_model_option` does not exist in `MODEL_MAP`.
     """
+
     chat_model = MODEL_MAP.get(chat_model_option)
     # Load generation configuration from JSON
-    generation_config: GenerationConfig = load_generation_config("examples/multi-agent-debate/generation_config.json")
+    generation_config: GenerationConfig = load_generation_config(
+        "examples/multi-agent-debate/generation_config.json"
+    )
 
     if not chat_model:
         raise ValueError(f"Invalid model selection: {chat_model_option}")
 
     # Determine max_output_tokens based on the selected model
-    max_output_tokens = (
-        MISTRAL_MAX_OUTPUT_TOKENS if chat_model_option == "7" else generation_config.max_output_tokens
+    max_output_tokens_config = (
+        MISTRAL_MAX_OUTPUT_TOKENS
+        if chat_model_option == "7"
+        else generation_config.max_output_tokens
     )
 
     # Use passed temperature if provided; otherwise, use the one from the JSON config
-    effective_temperature = temperature if temperature is not None else generation_config.temperature
+    effective_temperature = (
+        temperature if temperature is not None else generation_config.temperature
+    )
 
     # Create and return the LLM configuration
     return OpenAIGPTConfig(
         chat_model=chat_model,
         min_output_tokens=generation_config.min_output_tokens,
-        max_output_tokens=generation_config.max_output_tokens,
+        max_output_tokens=max_output_tokens_config,
         temperature=effective_temperature,
-        seed=generation_config.seed
+        seed=generation_config.seed,
     )
 
 
-def get_base_llm_config(chat_model_option: str, temperature: Optional[float] = None) -> OpenAIGPTConfig:
+def get_base_llm_config(
+    chat_model_option: str, temperature: Optional[float] = None
+) -> OpenAIGPTConfig:
     """
     Prompt the user to select a base LLM configuration and return it.
 
@@ -96,4 +107,4 @@ def get_base_llm_config(chat_model_option: str, temperature: Optional[float] = N
     # Pass temperature only if it is provided
     if temperature is not None:
         return create_llm_config(chat_model_option, temperature)
-    return create_llm_config(chat_model_option)
+    return create_llm_config(chat_model_option)

examples/multi-agent-debate/generation_config_models.py

@@ -1,15 +1,25 @@
-from typing import List, Optional
-from pydantic import BaseModel, Field
+from typing import Optional
+from langroid.pydantic_v1 import BaseModel, Field
 import json
 
 
 class GenerationConfig(BaseModel):
     """Represents configuration for text generation."""
-    max_output_tokens: int = Field(default=1024, ge=1, description="Maximum output tokens.")
-    min_output_tokens: int = Field(default=1, ge=0, description="Minimum output tokens.")
-    temperature: float = Field(default=0.7, ge=0.0, le=1.0, description="Sampling temperature.")
-    seed: Optional[int] = Field(default=42, description="Seed for reproducibility. If set, ensures deterministic "
-                                                        "outputs for the same input.")
+
+    max_output_tokens: int = Field(
+        default=1024, ge=1, description="Maximum output tokens."
+    )
+    min_output_tokens: int = Field(
+        default=1, ge=0, description="Minimum output tokens."
+    )
+    temperature: float = Field(
+        default=0.7, ge=0.0, le=1.0, description="Sampling temperature."
+    )
+    seed: Optional[int] = Field(
+        default=42,
+        description="Seed for reproducibility. If set, ensures deterministic "
+        "outputs for the same input.",
+    )
 
 
 def load_generation_config(file_path: str) -> GenerationConfig:

examples/multi-agent-debate/main.py

@@ -20,6 +20,7 @@
     FEEDBACK_AGENT_SYSTEM_MESSAGE,
     generate_metaphor_search_agent_system_message,
 )
+
 # Import from utils.py
 from utils import (
     select_model,
@@ -32,9 +33,7 @@
 
 
 class MetaphorSearchChatAgent(ChatAgent):
-    def handle_message_fallback(
-            self, msg: str | ChatDocument
-    ) -> str | None:
+    def handle_message_fallback(self, msg: str | ChatDocument) -> str | None:
         """Handle scenario where LLM did not generate any Tool"""
         if isinstance(msg, ChatDocument) and msg.metadata.sender == Entity.LLM:
             return f"""
@@ -82,20 +81,18 @@ def parse_and_format_message_history(message_history: List[Any]) -> str:
 
 
 def create_chat_agent(
-        name: str,
-        llm_config: OpenAIGPTConfig,
-        system_message: str
+    name: str, llm_config: OpenAIGPTConfig, system_message: str
 ) -> ChatAgent:
     """creates a ChatAgent with the given parameters.
 
-        Args:
-            name (str): The name of the agent.
-            llm_config (OpenAIGPTConfig): The LLM configuration for the agent.
-            system_message (str): The system message to guide the agent's LLM.
+    Args:
+        name (str): The name of the agent.
+        llm_config (OpenAIGPTConfig): The LLM configuration for the agent.
+        system_message (str): The system message to guide the agent's LLM.
 
-        Returns:
-            ChatAgent: A configured ChatAgent instance.
-        """
+    Returns:
+        ChatAgent: A configured ChatAgent instance.
+    """
     return ChatAgent(
         ChatAgentConfig(
             llm=llm_config,
@@ -131,9 +128,9 @@ def run_debate() -> None:
 
     # Get base LLM configuration
     if same_llm:
-
         shared_agent_config: OpenAIGPTConfig = get_base_llm_config(
-                                                select_model("main LLM"))
+            select_model("main LLM")
+        )
         pro_agent_config = con_agent_config = shared_agent_config
 
         # Create feedback_agent_config by modifying shared_agent_config
@@ -146,29 +143,40 @@ def run_debate() -> None:
         )
         metaphor_search_agent_config = feedback_agent_config
     else:
-        pro_agent_config: OpenAIGPTConfig = get_base_llm_config(select_model("for Pro Agent"))
-        con_agent_config: OpenAIGPTConfig = get_base_llm_config(select_model("for Con Agent"))
-        feedback_agent_config: OpenAIGPTConfig = get_base_llm_config(select_model("feedback"),temperature=0.2)
+        pro_agent_config: OpenAIGPTConfig = get_base_llm_config(
+            select_model("for Pro Agent")
+        )
+        con_agent_config: OpenAIGPTConfig = get_base_llm_config(
+            select_model("for Con Agent")
+        )
+        feedback_agent_config: OpenAIGPTConfig = get_base_llm_config(
+            select_model("feedback"), temperature=0.2
+        )
         metaphor_search_agent_config = feedback_agent_config
 
-    system_messages: SystemMessages = load_system_messages("examples/multi-agent-debate/system_messages.json")
+    system_messages: SystemMessages = load_system_messages(
+        "examples/multi-agent-debate/system_messages.json"
+    )
     topic_name, pro_key, con_key, side = select_topic_and_setup_side(system_messages)
 
     # Generate the system message
-    metaphor_search_agent_system_message = (generate_metaphor_search_agent_system_message(
-                                            system_messages, pro_key, con_key))
-
-    pro_agent = create_chat_agent("Pro",
-                                  pro_agent_config,
-                                  system_messages.messages[pro_key].message +
-                                  DEFAULT_SYSTEM_MESSAGE_ADDITION)
-    con_agent = create_chat_agent("Con",
-                                  con_agent_config,
-                                  system_messages.messages[con_key].message +
-                                  DEFAULT_SYSTEM_MESSAGE_ADDITION)
-    feedback_agent = create_chat_agent("Feedback",
-                                       feedback_agent_config,
-                                       FEEDBACK_AGENT_SYSTEM_MESSAGE)
+    metaphor_search_agent_system_message = (
+        generate_metaphor_search_agent_system_message(system_messages, pro_key, con_key)
+    )
+
+    pro_agent = create_chat_agent(
+        "Pro",
+        pro_agent_config,
+        system_messages.messages[pro_key].message + DEFAULT_SYSTEM_MESSAGE_ADDITION,
+    )
+    con_agent = create_chat_agent(
+        "Con",
+        con_agent_config,
+        system_messages.messages[con_key].message + DEFAULT_SYSTEM_MESSAGE_ADDITION,
+    )
+    feedback_agent = create_chat_agent(
+        "Feedback", feedback_agent_config, FEEDBACK_AGENT_SYSTEM_MESSAGE
+    )
     metaphor_search_agent = MetaphorSearchChatAgent(  # Use the subclass here
         ChatAgentConfig(
             llm=metaphor_search_agent_config,
@@ -180,7 +188,10 @@ def run_debate() -> None:
     logger.info("Pro, Con, feedback, and metaphor_search agents created.")
 
     # Determine user's side and assign user_agent and ai_agent based on user selection
-    agents = {"pro": (pro_agent, con_agent, "Pro", "Con"), "con": (con_agent, pro_agent, "Con", "Pro")}
+    agents = {
+        "pro": (pro_agent, con_agent, "Pro", "Con"),
+        "con": (con_agent, pro_agent, "Con", "Pro"),
+    }
     user_agent, ai_agent, user_side, ai_side = agents[side]
     logger.info(
         f"Starting debate on topic: {topic_name}, taking the {user_side} side. "

examples/multi-agent-debate/models.py

@@ -1,5 +1,5 @@
 from typing import Dict
-from pydantic import BaseModel
+from langroid.pydantic_v1 import BaseModel
 import json
 import logging
 from langroid.utils.logging import setup_logger
@@ -16,6 +16,7 @@ class Message(BaseModel):
         topic (str): The topic of the message.
         message (str): The content of the message.
     """
+
     topic: str
     message: str
 
@@ -27,6 +28,7 @@ class SystemMessages(BaseModel):
         messages (Dict[str, Message]): A dictionary where the key is the message
             identifier (e.g., 'pro_ai') and the value is a `Message` object.
     """
+
     messages: Dict[str, Message]
 
 

examples/multi-agent-debate/system_messages.py

@@ -2,11 +2,11 @@
 from langroid.agent.tools.orchestration import DoneTool
 
 
-DEFAULT_SYSTEM_MESSAGE_ADDITION = f"""
+DEFAULT_SYSTEM_MESSAGE_ADDITION = """
             DO NOT REPEAT ARGUMENTS THAT HAVE BEEN PREVIOUSLY GENERATED 
             AND CAN BE SEEN IN THE DEBATE HISTORY PROVIDED. 
             """
-FEEDBACK_AGENT_SYSTEM_MESSAGE = f"""  
+FEEDBACK_AGENT_SYSTEM_MESSAGE = """  
             You are an expert and experienced judge specializing in Lincoln-Douglas style debates. 
             Your goal is to evaluate the debate thoroughly based on the following criteria:
             1. Clash of Values: Assess how well each side upholds their stated value (e.g., justice, morality) 
@@ -67,5 +67,5 @@ def generate_metaphor_search_agent_system_message(system_messages, pro_key, con_
         metaphor_tool_name=MetaphorSearchTool.name(),
         pro_message=system_messages.messages[pro_key].message,
         con_message=system_messages.messages[con_key].message,
-        done_tool_name=DoneTool.name()
+        done_tool_name=DoneTool.name(),
     )

examples/multi-agent-debate/utils.py

@@ -31,9 +31,7 @@ def extract_topics(system_messages: SystemMessages) -> List[Tuple[str, str, str]
     for key, message in system_messages.messages.items():
         # Process only "pro_" keys to avoid duplicates
         if key.startswith("pro_"):
-            con_key = key.replace("pro_",
-                                  "con_",
-                                  1)  # Match "con_" dynamically
+            con_key = key.replace("pro_", "con_", 1)  # Match "con_" dynamically
             if con_key in system_messages.messages:  # Ensure "con_" exists
                 topics.append((message.topic, key, con_key))
     return topics
@@ -134,7 +132,9 @@ def select_side(topic_name: str) -> Literal["pro", "con"]:
     return "pro" if side == "1" else "con"
 
 
-def select_topic_and_setup_side(system_messages: SystemMessages) -> Tuple[str, str, str, str]:
+def select_topic_and_setup_side(
+    system_messages: SystemMessages,
+) -> Tuple[str, str, str, str]:
     """Prompt the user to select a debate topic and sets up the respective side.
 
     This function handles the user interaction for selecting a debate topic and the side
@@ -199,11 +199,11 @@ def is_metaphor_search_key_set() -> bool:
 def is_same_llm_for_all_agents() -> bool:
     """Prompt the user to decide if same LLM should be used for all agents.
 
-       Asks the user whether the same LLM should be configured for all agents.
+    Asks the user whether the same LLM should be configured for all agents.
 
-       Returns:
-           bool: True if the user chooses same LLM for all agents, otherwise return False.
-       """
+    Returns:
+        bool: True if the user chooses same LLM for all agents, otherwise return False.
+    """
     # Ask the user if they want to use the same LLM configuration for all agents
     return Confirm.ask(
         "Do you want to use the same LLM for all agents?",
@@ -214,7 +214,10 @@ def is_same_llm_for_all_agents() -> bool:
 def select_max_debate_turns() -> int:
     # Prompt for number of debate turns
     while True:
-        max_turns = Prompt.ask(f"How many turns should the debate continue for?", default=str(DEFAULT_TURN_COUNT))
+        max_turns = Prompt.ask(
+            "How many turns should the debate continue for?",
+            default=str(DEFAULT_TURN_COUNT),
+        )
         try:
             return int(max_turns)
         except ValueError: