multi-llm-consensus 0.1.3__py3-none-any.whl

llm_ensemble/__init__.py

@@ -0,0 +1,4 @@
+from .run_llm import RunLLM
+from .consensus import Consensus
+
+__all__ = ["RunLLM", "Consensus"]

llm_ensemble/consensus.py

@@ -0,0 +1,165 @@
+from langchain.agents import create_agent
+from langchain.agents.middleware import TodoListMiddleware, SummarizationMiddleware, ToolCallLimitMiddleware
+from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.backends import StateBackend
+from langchain.chat_models import init_chat_model
+from langchain.tools import tool
+from .run_llm import RunLLM
+from pathlib import Path
+from typing import Type
+
+
+class Consensus:
+    """
+    Consensus class that uses a configurable judge model to orchestrate
+    multiple RunLLM invocations until consensus is reached among LLMs.
+    """
+
+    def __init__(
+        self,
+        models: list[str],
+        judge_model: str = "anthropic:claude-opus-4-5-20251101",
+        summarization_model: str = "claude-4-5-sonnet-20250929",
+        summarization_trigger_tokens: int = 200_000,
+        summarization_keep_messages: int = 5,
+        run_limit: int = 20,
+        response_schema: Type | None = None
+    ):
+        """
+        Initialize the Consensus class.
+
+        Args:
+            models: List of model strings in format "provider:model-name".
+            judge_model: Model string for the judge coordinator in format "provider:model-name".
+                        Defaults to "anthropic:claude-opus-4-5-20251101".
+            summarization_model: Model string for summarization middleware in format "provider:model-name".
+                        Defaults to "anthropic:claude-3-5-sonnet-20241022".
+            summarization_trigger_tokens: Token count to trigger summarization middleware.
+            summarization_keep_messages: Number of messages to keep after summarization.
+            run_limit: Maximum number of calls to run_llms tool per invocation.
+            response_schema: Optional schema for structured output (TypedDict or Pydantic model).
+                            If None, returns full agent result without structured output.
+
+        Raises:
+            ValueError: If models list is empty or contains only one model.
+        """
+        if not models:
+            raise ValueError("models list cannot be empty")
+        if len(models) < 2:
+            raise ValueError("models list must contain at least 2 models for consensus")
+
+        # Store as instance variables for use in tool creation
+        self.models = models
+        self.system_message = "You are a helpful AI assistant."
+
+        # Load judge prompt
+        judge_prompt_path = Path(__file__).parent / "prompts" / "judge.prompt"
+        judge_prompt = judge_prompt_path.read_text()
+
+        # Create the run_llms tool
+        run_llms = self._create_run_llms_tool()
+
+        # Create judge LLM using init_chat_model
+        llm = init_chat_model(judge_model)
+
+        # Create middleware
+        middleware = [
+            TodoListMiddleware(),
+            FilesystemMiddleware(backend=lambda rt: StateBackend(rt)),
+            SummarizationMiddleware(
+                model=summarization_model,
+                trigger=("tokens", summarization_trigger_tokens),
+                keep=("messages", summarization_keep_messages)
+            ),
+            ToolCallLimitMiddleware(
+                tool_name="run_llms",
+                run_limit=run_limit,
+                exit_behavior="error"
+            )
+        ]
+
+        # Create agent with optional structured output
+        if response_schema is not None:
+            self._agent = create_agent(
+                model=llm,
+                tools=[run_llms],
+                system_prompt=judge_prompt,
+                middleware=middleware,
+                response_format=response_schema
+            )
+        else:
+            self._agent = create_agent(
+                model=llm,
+                tools=[run_llms],
+                system_prompt=judge_prompt,
+                middleware=middleware
+            )
+
+        self._response_schema = response_schema
+
+    def _create_run_llms_tool(self):
+        """
+        Creates the run_llms tool with access to instance variables.
+
+        Returns:
+            A LangChain tool that runs multiple LLMs in parallel.
+        """
+        @tool
+        def run_llms(query: str) -> str:
+            """
+            Runs multiple LLMs in parallel on the same query.
+
+            Args:
+                query: The prompt/question to send to all LLMs. Include full context and
+                       any specific instructions (e.g., "use search_the_web for web search",
+                       "use add/multiply/subtract/divide tools for calculations").
+
+            Returns:
+                Aggregated responses from all LLMs. Each response is prefixed with the
+                exact model identifier (e.g., "openai:gpt-5-mini:", "google_genai:gemini-3-flash-preview:").
+                Always refer to models by these exact identifiers in your analysis.
+            """
+            run_llm = RunLLM(models=self.models, system_message=self.system_message)
+            return run_llm.invoke(query)
+
+        return run_llms
+
+    def invoke(self, prompt: str):
+        """
+        Invoke the consensus process with a user query.
+
+        Args:
+            prompt: The user's initial query
+
+        Returns:
+            If response_schema was provided: structured response dict (or default values on error)
+            Otherwise: full agent result (or None on error)
+        """
+        try:
+            result = self._agent.invoke({
+                "messages": [{"role": "user", "content": prompt}]
+            })
+            if self._response_schema is not None:
+                return result["structured_response"]
+            else:
+                return result
+        except Exception as e:
+            # Tool call limit reached or other error
+            print(f"Error during consensus: {str(e)}")
+            if self._response_schema is not None:
+                # Return default values - create a dict with all schema keys set to defaults
+                # This tries to match common schema patterns
+                default_dict = {}
+                if hasattr(self._response_schema, '__annotations__'):
+                    for key, type_hint in self._response_schema.__annotations__.items():
+                        if key in ['consensus', 'consensus_reached']:
+                            default_dict[key] = False
+                        elif type_hint == bool:
+                            default_dict[key] = False
+                        elif type_hint == str:
+                            default_dict[key] = f"Error occurred: {str(e)}"
+                        else:
+                            default_dict[key] = None
+                return default_dict if default_dict else None
+            else:
+                return None

llm_ensemble/prompts/judge.prompt

@@ -0,0 +1,38 @@
+You are a consensus coordinator for multiple AI language models. Your role is to facilitate agreement among different LLMs by iteratively querying them and refining your questions based on their responses.
+
+## Your Tools (Judge)
+
+**run_llms**: Runs multiple LLMs in parallel. Takes a `query` parameter where you craft the prompt to send to all LLMs.
+
+**TODO list**: Track agreements reached, disagreements to resolve, and clarifications needed across iterations.
+
+**Filesystem** (`write_file`, `read_file`, `ls`): After the first run_llms call, save the exact LLM model identifiers to a file and add a TODO reminder to read this file before providing the final answer to ensure model names are accurate.
+
+## Your Process
+
+1. **Initial Query**: Call `run_llms` with the user's question
+2. **Analyze Responses**: Identify agreements, disagreements, and areas needing clarification
+3. **Iterative Refinement**: Call `run_llms` again with updated queries that summarize the objective/context and clarify specific points where models diverged
+4. **Continue Until Consensus**: Iterate until LLMs substantially agree or you can draw a reasonable conclusion
+
+## Context Management - CRITICAL
+
+**LLMs ARE STATELESS.** They have NO memory of previous iterations. In every query after the first, you MUST include:
+
+1. **Original Question**: Restate the user's question or provide a summary
+2. **Previous Iterations**: Summarize what each model said in prior rounds. **IMPORTANT: Always refer to models by their exact identifiers as shown in the run_llms output** (e.g., "openai:gpt-5-mini said X", "google_genai:gemini-3-flash-preview said Y"). Never use shortened or friendly names.
+3. **Current Status**: Explain where you are now, what's agreed upon, and what needs resolution
+4. **Complete Context**: Treat each query as if the LLMs are starting fresh—provide everything they need to answer meaningfully
+
+## LLM Tools (Instruct LLMs to Use)
+
+When crafting queries for `run_llms`, instruct the LLMs to use their available tools:
+
+- **search_the_web**: For current events, recent information, factual verification, or when the user requests web search. If used in iteration 1, in subsequent iterations tell LLMs to use only if needed
+- **Calculation tools** (`add`, `subtract`, `multiply`, `divide`): If the user query implies calculations, tell LLMs to use these tools
+
+## Critical Guidelines
+
+- **Use exact model identifiers**: Always refer to models by their full identifiers as they appear in run_llms 
+- Base consensus ONLY on what the LLMs tell you, not your own knowledge
+- Be completely unbiased—evaluate all responses objectively and equally

llm_ensemble/run_llm.py

@@ -0,0 +1,151 @@
+from dotenv import load_dotenv
+from langgraph.graph import StateGraph, START, END
+from langgraph.prebuilt import create_react_agent
+from langchain_core.messages import SystemMessage, HumanMessage
+from .utils import add, subtract, multiply, divide, search_the_web
+from .schemas import InputState, OutputState, RunLLMState
+
+# Load environment variables at module level
+load_dotenv()
+
+
+class RunLLM:
+    """
+    RunLLM class that runs multiple LLM agents in parallel on the same query,
+    then aggregates their responses.
+    """
+
+    def __init__(self, models: list[str], system_message: str):
+        """
+        Initialize the RunLLM class.
+
+        Args:
+            models: List of model strings in format "provider:model-name"
+            system_message: System message to include in every agent invocation
+        """
+        self._models = models
+        self._system_message = system_message
+
+        # Create tool list
+        tools = [
+            search_the_web,
+            add,
+            subtract,
+            multiply,
+            divide
+        ]
+
+        # Initialize react agents for each model
+        self._agents = {}
+        for model_string in models:
+            # Pass model string directly to create_react_agent
+            # LangChain's init_chat_model handles provider parsing automatically
+            agent = create_react_agent(
+                model=model_string,
+                tools=tools
+            )
+            self._agents[model_string] = agent
+
+        # Build and compile the StateGraph
+        self._graph = self._build_graph()
+
+    def _build_graph(self):
+        """
+        Build and compile the StateGraph.
+
+        Returns:
+            Compiled graph ready for invocation
+        """
+        # Initialize StateGraph with input/output schemas
+        graph = StateGraph(
+            state_schema=RunLLMState,
+            input=InputState,
+            output=OutputState
+        )
+
+        # Factory function to create model nodes with proper closure
+        def make_model_node(model_name: str, agent, system_message: str):
+            """Factory function to create a node function with proper closure."""
+            def node_function(state: RunLLMState) -> dict:
+                prompt = state["prompt"]
+                # Invoke react agent with system message and user prompt
+                result = agent.invoke({
+                    "messages": [
+                        SystemMessage(content=system_message),
+                        HumanMessage(content=prompt)
+                    ]
+                })
+                # Extract final AI message content
+                content = result["messages"][-1].content
+
+                # Handle different content formats from different providers
+                # Gemini returns: [{'type': 'text', 'text': '...', 'extras': {...}}]
+                # OpenAI/Anthropic return: plain string
+                if isinstance(content, list) and len(content) > 0:
+                    # Extract text from Gemini's structured format
+                    output_text = content[0].get('text', str(content))
+                else:
+                    # Use content directly for OpenAI/Anthropic
+                    output_text = content
+
+                # Return update to model_outputs dict
+                return {"model_outputs": {model_name: output_text}}
+            return node_function
+
+        # Add a node for each model
+        # Use sanitized node names (replace : with _) since LangGraph doesn't allow colons
+        for model_name in self._models:
+            node_fn = make_model_node(
+                model_name,
+                self._agents[model_name],
+                self._system_message
+            )
+            # Sanitize node name by replacing : with _
+            sanitized_node_name = model_name.replace(":", "_")
+            graph.add_node(sanitized_node_name, node_fn)
+
+        # Add process node
+        def process_node(state: RunLLMState) -> dict:
+            """Aggregate all model outputs in order."""
+            outputs = []
+            for model_name in self._models:
+                output = state["model_outputs"].get(model_name, "")
+                outputs.append(f"{model_name}:\n{output}")
+
+            aggregated = "\n\n".join(outputs)
+            return {"result": aggregated}
+
+        graph.add_node("process", process_node)
+
+        # Add edges
+        # From START to each model node
+        for model_name in self._models:
+            sanitized_node_name = model_name.replace(":", "_")
+            graph.add_edge(START, sanitized_node_name)
+
+        # From each model node to process
+        for model_name in self._models:
+            sanitized_node_name = model_name.replace(":", "_")
+            graph.add_edge(sanitized_node_name, "process")
+
+        # From process to END
+        graph.add_edge("process", END)
+
+        # Compile and return
+        return graph.compile()
+
+    def invoke(self, prompt: str) -> str:
+        """
+        Invoke the graph with a prompt.
+
+        Args:
+            prompt: The user's query
+
+        Returns:
+            Aggregated responses from all models
+        """
+        # Thanks to input/output schema configuration,
+        # we can pass just the prompt string
+        result = self._graph.invoke({"prompt": prompt})
+        # Result dict contains only the output state fields
+        return result["result"]

llm_ensemble/schemas/__init__.py

@@ -0,0 +1,3 @@
+from .schemas import InputState, OutputState, RunLLMState
+
+__all__ = ["InputState", "OutputState", "RunLLMState"]

llm_ensemble/schemas/schemas.py

@@ -0,0 +1,20 @@
+from typing import TypedDict, Annotated
+from operator import or_
+
+
+class InputState(TypedDict):
+    """Input schema: what users provide when invoking."""
+    prompt: str
+
+
+class OutputState(TypedDict):
+    """Output schema: what the graph returns."""
+    result: str
+
+
+class RunLLMState(TypedDict):
+    """Overall state: internal state during execution."""
+    prompt: str
+    # Use or_ reducer to merge dict updates from parallel nodes
+    model_outputs: Annotated[dict[str, str], or_]
+    result: str

llm_ensemble/utils/__init__.py

@@ -0,0 +1,4 @@
+from .utils import add, subtract, multiply, divide
+from .tavily_tool import search_the_web
+
+__all__ = ["add", "subtract", "multiply", "divide", "search_the_web"]

llm_ensemble/utils/tavily_tool.py

@@ -0,0 +1,30 @@
+import os
+from langchain_core.tools import tool
+from tavily import TavilyClient
+
+
+@tool
+def search_the_web(query: str):
+    """
+    Search the internet for current events, news, and real-time information.
+    Use this for any questions about the world that require up-to-date data.
+    """
+    # Initialize Tavily Client (lazy initialization to ensure env vars are loaded)
+    tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+
+    # Execute the search using the raw SDK
+    response = tavily.search(
+        query=query,
+        max_results=10,
+        search_depth="basic"
+    )
+
+    # Format the results into a clean string for the LLM
+    # This prevents the LLM from getting confused by raw JSON metadata
+    formatted_results = []
+    for res in response['results']:
+        formatted_results.append(
+            f"Title: {res['title']}\nURL: {res['url']}\nContent: {res['content']}\n"
+        )
+
+    return "\n---\n".join(formatted_results)

llm_ensemble/utils/utils.py

@@ -0,0 +1,27 @@
+from langchain_core.tools import tool
+
+
+@tool
+def add(a: float, b: float) -> float:
+    """Add two numbers together."""
+    return a + b
+
+
+@tool
+def subtract(a: float, b: float) -> float:
+    """Subtract b from a."""
+    return a - b
+
+
+@tool
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers together."""
+    return a * b
+
+
+@tool
+def divide(a: float, b: float) -> float:
+    """Divide a by b."""
+    if b == 0:
+        raise ValueError("Cannot divide by zero")
+    return a / b

multi_llm_consensus-0.1.3.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: multi-llm-consensus
+Version: 0.1.3
+Summary: Achieve consensus across multiple LLMs through an AI judge coordinator
+Project-URL: Homepage, https://github.com/zzzrbx/llm-ensemble
+Project-URL: Repository, https://github.com/zzzrbx/llm-ensemble
+Project-URL: Issues, https://github.com/zzzrbx/llm-ensemble/issues
+Author-email: Roberto Pagliari <roberto.pagliari@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,consensus,langchain,langgraph,llm,multi-model
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: deepagents>=0.1.0
+Requires-Dist: langchain-anthropic>=1.3.1
+Requires-Dist: langchain-community>=0.4.1
+Requires-Dist: langchain-google-genai>=4.1.3
+Requires-Dist: langchain-openai>=1.1.7
+Requires-Dist: langchain-xai>=1.2.1
+Requires-Dist: langchain>=1.2.3
+Requires-Dist: langgraph>=1.0.5
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: rich>=14.2.0
+Requires-Dist: tavily-python>=0.7.17
+Description-Content-Type: text/markdown
+
+# LLM Ensemble
+
+![LLM Ensemble Banner](.github/banner.png)
+
+A Python library for achieving consensus across multiple Agents.
+
+## Features
+
+- **Consensus**: Uses a moderator to iteratively coordinate multiple LLMs until consensus is reached
+- Can use any model API based model such as OpenAI, Anthropic, Gemini, Grok supported by Langgraph
+- Supports web search for real-time data 
+
+## Installation
+
+```bash
+uv add multi-llm-consensus
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/zzzrbx/llm-ensemble.git
+cd llm-ensemble
+uv sync
+```
+
+## Environment Setup
+
+Create a `.env` file with your API keys, for example:
+
+```bash
+OPENAI_API_KEY=your_openai_key
+ANTHROPIC_API_KEY=your_anthropic_key
+GOOGLE_API_KEY=your_google_key
+XAI_API_KEY=your_xai_key
+TAVILY_API_KEY=your_tavily_key  # For web search
+```
+
+You must provide at least two API keys for the models you want to use in the ensemble.
+
+## How It Works
+
+```
+User Query → Judge (configurable, default: Claude Opus 4.5)
+    ↓
+Judge calls run_llms tool
+    ├── Model A (parallel)
+    ├── Model B (parallel)
+    ├── Model C (parallel)
+    └── Model D (parallel)
+         ↓
+Judge analyzes responses
+    ├── Consensus? → Return answer
+    └── No consensus? → Refine query and call run_llms again
+         ↓
+Repeat until consensus or limit reached
+```
+
+**Key Features:**
+- **Dynamic queries** - Judge crafts different prompts each iteration:
+  - Iteration 1: Sends initial question with research instructions
+  - Iteration 2+: Summarizes agreements, highlights disagreements, requests refinements
+  - Final iteration: Presents refined consensus statement for confirmation
+- **Error handling** - Returns default values on timeout or tool call limit reached
+
+**Tools currently available for LLMs:**
+- `search_the_web` - Tavily web search for current events and factual data
+- `add`, `subtract`, `multiply`, `divide` - Math operations
+
+
+## Examples
+
+### Example 1: With structured output
+
+```python
+from typing import TypedDict
+from llm_ensemble import Consensus
+
+class UserSchema(TypedDict):
+    consensus: bool
+    final_answer: str
+    notes: str
+
+consensus = Consensus(
+    models=[
+        "openai:gpt-5-mini",
+        "google_genai:gemini-3-flash-preview",
+        "anthropic:claude-3-5-haiku-20241022",
+        "xai:grok-3-mini",
+    ],
+    response_schema=UserSchema
+)
+
+result = consensus.invoke(
+    "If survival is arbitrary, is moral judgment arbitrary too?"
+)
+
+print(f"Consensus: {result['consensus']}")
+print(f"Answer: {result['final_answer']}")
+print(f"Notes: {result['notes']}")
+```
+
+### Example 2: No structured output with web search enabled (you just need to mention it in the prompt)
+
+```python
+from llm_ensemble import Consensus
+
+# No response_schema - returns full agent result
+consensus = Consensus(
+    models=[
+        "openai:gpt-5-mini",
+        "google_genai:gemini-3-flash-preview",
+        "anthropic:claude-3-5-haiku-20241022",
+        "xai:grok-3-mini",
+    ]
+)
+
+result = consensus.invoke(
+    "What are the latest developments in quantum computing?\n\n"
+    "Use the web search to research current news and breakthroughs."
+)
+
+# Access full agent result
+print(result['messages'][-1].content)
+```
+
+## Debugging and Observability
+
+The library integrates with LangSmith for trace observability. Set `LANGSMITH_API_KEY` and `LANGSMITH_PROJECT` in your `.env` file to enable tracing.
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+

multi_llm_consensus-0.1.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+llm_ensemble/__init__.py,sha256=PW0ymnE-IE7oDqLm2XRP7kzPj2CfiWaFFT40HXB_bDs,96
+llm_ensemble/consensus.py,sha256=EEwa4nOeLHiVwD9-VmvKmiL6YcEp5eYRqkEVtyEdapg,6688
+llm_ensemble/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+llm_ensemble/run_llm.py,sha256=fDPIBelDlV8Jcvs-mAHMwMAotp3y60U5zASDlEDba00,5375
+llm_ensemble/prompts/judge.prompt,sha256=xIMhW6pzJC1c3EE-QD4iW9CK7PI-Gv6-NOamxHpQ2DM,2646
+llm_ensemble/schemas/__init__.py,sha256=4m6x_Ao8ZHShyu7U1U237zkDHmXWgqSdHp0-TA1HjoU,114
+llm_ensemble/schemas/schemas.py,sha256=lSYjKAsC_7m3K5AVRgUquYtg2DW3LXBbwAp6OT9ObnU,503
+llm_ensemble/utils/__init__.py,sha256=6NgwRGS0pN9V0kEwU8lLKkkyWgeKurh2F3OIUA6cbkY,162
+llm_ensemble/utils/tavily_tool.py,sha256=Q2S-VwxTJgAqtXUk8_uMo3Fa5MWaZK_MbDri3_OderI,957
+llm_ensemble/utils/utils.py,sha256=57VHE7LnlpHPGcaGsrFDZU978AtEA70VuKVBxVRvHOI,499
+multi_llm_consensus-0.1.3.dist-info/METADATA,sha256=H4feUKu_CohokI17rEbFKVogHHpOQ92FoOSJEzGiUgI,4839
+multi_llm_consensus-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+multi_llm_consensus-0.1.3.dist-info/licenses/LICENSE,sha256=89cjtVjCzuOkNauPK_zp0h75f8q3bN-L12lX6MYkjyU,1073
+multi_llm_consensus-0.1.3.dist-info/RECORD,,

multi_llm_consensus-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

multi_llm_consensus-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Pagliari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.