ultragpt 0.1.0__tar.gz

ultragpt-0.1.0/LICENSE.rst

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Ranit Bhowmick
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software") to use the Software without restriction but is prohibited to 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:
+
+1. The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+2. Credit must be given to the original author, Ranit Bhowmick, in any
+   use, distribution, or publication 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.

ultragpt-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include README.md

ultragpt-0.1.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.1
+Name: ultragpt
+Version: 0.1.0
+Summary: UltraGPT: A modular library for advanced GPT-based reasoning and step pipelines
+Home-page: https://github.com/Kawai-Senpai
+Author: Ranit Bhowmick
+Author-email: bhowmickranitking@duck.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.rst
+
+# 🤖 UltraGPT
+
+**A powerful and modular library for advanced GPT-based reasoning and step pipelines**
+
+## 🌟 Features
+
+- **📝 Steps Pipeline:** Break down complex tasks into manageable steps
+  - Automatic step generation and processing
+  - Verification at each step
+  - Detailed progress tracking
+
+- **🧠 Reasoning Pipeline:** Advanced reasoning capabilities
+  - Multi-iteration thought process
+  - Building upon previous reasoning
+  - Comprehensive analysis
+
+- **🛠️ Tool Integration:** 
+  - Web search capabilities
+  - Calculator functionality
+  - Extensible tool framework
+
+## 📦 Installation
+
+```bash
+pip install git+https://github.com/Kawai-Senpai/UltraGPT.git
+```
+
+## 🚀 Quick Start
+
+```python
+from ultragpt import UltraGPT
+
+if __name__ == "__main__":
+    # Initialize UltraGPT
+    ultragpt = UltraGPT(
+        api_key="your-openai-api-key",
+        verbose=True
+    )
+
+    # Example chat session
+    final_output, tokens_used, details = ultragpt.chat([
+        {"role": "user", "content": "Write a story about an elephant."}
+    ])
+
+    print("Final Output:", final_output)
+    print("Total tokens used:", tokens_used)
+```
+
+## 📚 Advanced Usage
+
+### Customizing Pipeline Settings
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    model="gpt-4o",  # Specify model
+    temperature=0.7,  # Adjust creativity
+    reasoning_iterations=3,  # Set reasoning depth
+    steps_pipeline=True,
+    reasoning_pipeline=True,
+    verbose=True
+)
+```
+
+### Using Tools
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    tools=["web-search", "calculator"],
+    tools_config={
+        "web-search": {
+            "max_results": 1,
+            "model": "gpt-4o"
+        },
+        "calculator": {
+            "model": "gpt-4o"
+        }
+    }
+)
+```
+
+## 🔧 Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | str | Required | Your OpenAI API key |
+| `model` | str | "gpt-4o" | Model to use |
+| `temperature` | float | 0.7 | Output randomness |
+| `reasoning_iterations` | int | 3 | Number of reasoning steps |
+| `tools` | list | [] | Enabled tools |
+| `verbose` | bool | False | Enable detailed logging |
+
+## 🌐 Tool System
+
+UltraGPT supports various tools to enhance its capabilities:
+
+### Web Search
+- Performs intelligent web searches
+- Summarizes findings
+- Integrates results into responses
+
+### Calculator
+- Handles mathematical operations
+- Supports complex calculations
+- Provides step-by-step solutions
+
+## 🔄 Pipeline System
+
+### Steps Pipeline
+1. Task Analysis
+2. Step Generation
+3. Step-by-Step Execution
+4. Progress Verification
+5. Final Compilation
+
+### Reasoning Pipeline
+1. Initial Analysis
+2. Multi-iteration Thinking
+3. Thought Development
+4. Conclusion Formation
+
+## 📋 Requirements
+
+- Python 3.6+
+- OpenAI API key
+- Internet connection (for web tools)
+
+## 🤝 Contributing
+
+Contributions are always welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/improvement`)
+3. Make changes
+4. Commit (`git commit -am 'Add new feature'`)
+5. Push (`git push origin feature/improvement`)
+6. Open a Pull Request
+
+## 📝 License
+
+This project is MIT licensed - see the [LICENSE](LICENSE) file for details.
+
+## 👥 Author
+
+**Ranit Bhowmick**
+- Email: bhowmickranitking@duck.com
+- GitHub: [@Kawai-Senpai](https://github.com/Kawai-Senpai)
+
+---
+
+<div align="center">
+Made with ❤️ by Ranit Bhowmick
+</div>

ultragpt-0.1.0/README.md

@@ -0,0 +1,154 @@
+# 🤖 UltraGPT
+
+**A powerful and modular library for advanced GPT-based reasoning and step pipelines**
+
+## 🌟 Features
+
+- **📝 Steps Pipeline:** Break down complex tasks into manageable steps
+  - Automatic step generation and processing
+  - Verification at each step
+  - Detailed progress tracking
+
+- **🧠 Reasoning Pipeline:** Advanced reasoning capabilities
+  - Multi-iteration thought process
+  - Building upon previous reasoning
+  - Comprehensive analysis
+
+- **🛠️ Tool Integration:** 
+  - Web search capabilities
+  - Calculator functionality
+  - Extensible tool framework
+
+## 📦 Installation
+
+```bash
+pip install git+https://github.com/Kawai-Senpai/UltraGPT.git
+```
+
+## 🚀 Quick Start
+
+```python
+from ultragpt import UltraGPT
+
+if __name__ == "__main__":
+    # Initialize UltraGPT
+    ultragpt = UltraGPT(
+        api_key="your-openai-api-key",
+        verbose=True
+    )
+
+    # Example chat session
+    final_output, tokens_used, details = ultragpt.chat([
+        {"role": "user", "content": "Write a story about an elephant."}
+    ])
+
+    print("Final Output:", final_output)
+    print("Total tokens used:", tokens_used)
+```
+
+## 📚 Advanced Usage
+
+### Customizing Pipeline Settings
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    model="gpt-4o",  # Specify model
+    temperature=0.7,  # Adjust creativity
+    reasoning_iterations=3,  # Set reasoning depth
+    steps_pipeline=True,
+    reasoning_pipeline=True,
+    verbose=True
+)
+```
+
+### Using Tools
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    tools=["web-search", "calculator"],
+    tools_config={
+        "web-search": {
+            "max_results": 1,
+            "model": "gpt-4o"
+        },
+        "calculator": {
+            "model": "gpt-4o"
+        }
+    }
+)
+```
+
+## 🔧 Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | str | Required | Your OpenAI API key |
+| `model` | str | "gpt-4o" | Model to use |
+| `temperature` | float | 0.7 | Output randomness |
+| `reasoning_iterations` | int | 3 | Number of reasoning steps |
+| `tools` | list | [] | Enabled tools |
+| `verbose` | bool | False | Enable detailed logging |
+
+## 🌐 Tool System
+
+UltraGPT supports various tools to enhance its capabilities:
+
+### Web Search
+- Performs intelligent web searches
+- Summarizes findings
+- Integrates results into responses
+
+### Calculator
+- Handles mathematical operations
+- Supports complex calculations
+- Provides step-by-step solutions
+
+## 🔄 Pipeline System
+
+### Steps Pipeline
+1. Task Analysis
+2. Step Generation
+3. Step-by-Step Execution
+4. Progress Verification
+5. Final Compilation
+
+### Reasoning Pipeline
+1. Initial Analysis
+2. Multi-iteration Thinking
+3. Thought Development
+4. Conclusion Formation
+
+## 📋 Requirements
+
+- Python 3.6+
+- OpenAI API key
+- Internet connection (for web tools)
+
+## 🤝 Contributing
+
+Contributions are always welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/improvement`)
+3. Make changes
+4. Commit (`git commit -am 'Add new feature'`)
+5. Push (`git push origin feature/improvement`)
+6. Open a Pull Request
+
+## 📝 License
+
+This project is MIT licensed - see the [LICENSE](LICENSE) file for details.
+
+## 👥 Author
+
+**Ranit Bhowmick**
+- Email: bhowmickranitking@duck.com
+- GitHub: [@Kawai-Senpai](https://github.com/Kawai-Senpai)
+
+---
+
+<div align="center">
+Made with ❤️ by Ranit Bhowmick
+</div>

ultragpt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ultragpt-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+# Get the long description from the README file
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding='utf-8')
+
+setup(
+    name='ultragpt',
+    version='0.1.0',
+    license="MIT",
+    author='Ranit Bhowmick',
+    author_email='bhowmickranitking@duck.com',
+    description='UltraGPT: A modular library for advanced GPT-based reasoning and step pipelines',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    packages=find_packages('src'),
+    package_dir={'': 'src'},
+    url='https://github.com/Kawai-Senpai',
+    install_requires=[
+        'pydantic',
+        'openai',
+        'ultraprint>=3.1.0',
+        'tqdm',
+        'click'
+    ],
+    python_requires='>=3.6',
+)

ultragpt-0.1.0/src/ultragpt/__init__.py

@@ -0,0 +1 @@
+from .core import UltraGPT

ultragpt-0.1.0/src/ultragpt/core.py

@@ -0,0 +1,534 @@
+from openai import OpenAI 
+import ultraprint.common as p
+from .prompts import (
+generate_steps_prompt, 
+each_step_prompt, generate_reasoning_prompt, 
+generate_conclusion_prompt, combine_all_pipeline_prompts,
+make_tool_analysis_prompt
+)
+from pydantic import BaseModel
+from .schemas import Steps, Reasoning
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from ultraprint.logging import logger
+from .schemas import ToolAnalysisSchema
+
+from .tools.web_search.main import _execute as web_search
+from .tools.calculator.main import _execute as calculator
+
+from itertools import islice
+
+class UltraGPT:
+    
+    def __init__(
+        self, 
+        api_key: str, 
+        model: str = None, 
+        temperature: float = 0.7, 
+        reasoning_iterations: int = 3,
+        steps_pipeline: bool = True,
+        reasoning_pipeline: bool = True,
+        verbose: bool = False,
+        logger_name: str = 'ultragpt',
+        logger_filename: str = 'debug/ultragpt.log',
+        log_extra_info: bool = False,
+        log_to_file: bool = False,
+        log_level: str = 'DEBUG',
+        tools: list = ["web-search", "calculator"],
+        tools_config: dict = {
+            "web-search": {
+                "max_results": 1,
+                "model": "gpt-4o"
+            },
+            "calculator": {
+                "model": "gpt-4o"
+            }
+        },
+        tool_batch_size: int = 3,  # New parameter for controlling batch size
+        tool_max_workers: int = 10, # New parameter for controlling max workers
+    ):
+        """
+        Initialize the UltraGPT class.
+        Args:
+            api_key (str): The API key for accessing the OpenAI service.
+            model (str, optional): The model to use. Defaults to "gpt-4o".
+            temperature (float, optional): The temperature for the model's output. Defaults to 0.7.
+            reasoning_iterations (int, optional): The number of reasoning iterations. Defaults to 3.
+            steps_pipeline (bool, optional): Whether to use steps pipeline. Defaults to True.
+            reasoning_pipeline (bool, optional): Whether to use reasoning pipeline. Defaults to True.
+            verbose (bool, optional): Whether to enable verbose logging. Defaults to False.
+            logger_name (str, optional): The name of the logger. Defaults to 'ultragpt'.
+            logger_filename (str, optional): The filename for the logger. Defaults to 'debug/ultragpt.log'.
+            log_extra_info (bool, optional): Whether to include extra info in logs. Defaults to False.
+            log_to_file (bool, optional): Whether to log to a file. Defaults to False.
+            log_level (str, optional): The logging level. Defaults to 'DEBUG'.
+            tools (list, optional): The list of tools to enable. Defaults to ["web-search", "calculator"].
+            tools_config (dict, optional): The configuration for the tools. Defaults to predefined configurations.
+            tool_batch_size (int, optional): The batch size for tool processing. Defaults to 3.
+            tool_max_workers (int, optional): The maximum number of workers for tool processing. Defaults to 10.
+        Raises:
+            ValueError: If an invalid tool is provided.
+        """
+
+        # Create the OpenAI client using the provided API key
+        self.openai_client = OpenAI(api_key=api_key)
+        self.model = model or "gpt-4o"
+        self.temperature = temperature
+        self.reasoning_iterations = reasoning_iterations
+        self.steps_pipeline = steps_pipeline
+        self.reasoning_pipeline = reasoning_pipeline
+        self.tools = tools
+        self.tools_config = tools_config
+        self.tool_batch_size = tool_batch_size
+        self.tool_max_workers = tool_max_workers
+        
+        supported_tools = ["web-search", "calculator"]
+        for tool in tools:
+            if tool not in supported_tools:
+                raise ValueError(f"Invalid tool: {tools}. Supported tools: {', '.join(supported_tools)}")
+
+        self.verbose = verbose
+        self.log = logger(
+            name=logger_name,
+            filename=logger_filename,
+            include_extra_info=log_extra_info,
+            write_to_file=log_to_file,
+            log_level=log_level,
+            log_to_console=False  # Always disable console logging
+        )
+        
+        self.log.info("Initializing UltraGPT with model: %s", self.model)
+        if self.verbose:
+            p.blue("="*50)
+            p.blue("Initializing UltraGPT")
+            p.cyan(f"Model: {self.model}")
+            if tools:
+                p.cyan(f"Tools enabled: {', '.join(tools)}")
+            p.blue("="*50)
+
+    def chat_with_openai_sync(self, messages: list):
+        """
+        Sends a synchronous chat request to OpenAI and processes the response.
+        Args:
+            messages (list): A list of message dictionaries to be sent to OpenAI.
+        Returns:
+            tuple: A tuple containing the response content (str) and the total number of tokens used (int).
+        Raises:
+            Exception: If the request to OpenAI fails.
+        Logs:
+            Debug: Logs the number of messages sent, the number of tokens in the response, and any errors encountered.
+            Verbose: Optionally logs detailed steps of the request and response process.
+        """
+        try:
+            self.log.debug("Sending request to OpenAI (msgs: %d)", len(messages))
+            if self.verbose:
+                p.cyan(f"\nOpenAI Request → Messages: {len(messages)}")
+                p.yellow("Checking for tool needs...")
+            
+            tool_response = self.execute_tools(messages[-1]["content"], messages)
+            if tool_response:
+                if self.verbose:
+                    p.cyan("\nAppending tool responses to message")
+                tool_response = "Tool Responses:\n" + tool_response
+                messages = self.append_message_to_system(messages, tool_response)
+            elif self.verbose:
+                p.dgray("\nNo tool responses needed")
+            
+            response = self.openai_client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                stream=False,
+                temperature=self.temperature
+            )
+            content = response.choices[0].message.content.strip()
+            tokens = response.usage.total_tokens
+            self.log.debug("Response received (tokens: %d)", tokens)
+            if self.verbose:
+                p.green(f"✓ Response received ({tokens} tokens)")
+            return content, tokens
+        except Exception as e:
+            self.log.error("OpenAI sync request failed: %s", str(e))
+            if self.verbose:
+                p.red(f"✗ OpenAI request failed: {str(e)}")
+            raise e
+
+    def chat_with_model_parse(self, messages: list, schema=None):
+        """
+        Sends a chat message to the model for parsing and returns the parsed response.
+        Args:
+            messages (list): A list of message dictionaries to be sent to the model.
+            schema (optional): The schema to be used for parsing the response. Defaults to None.
+        Returns:
+            tuple: A tuple containing the parsed content and the total number of tokens used.
+        Raises:
+            Exception: If the parse request fails.
+        """
+        try:
+            self.log.debug("Sending parse request with schema: %s", schema)
+            
+            tool_response = self.execute_tools(messages[-1]["content"], messages)
+            if tool_response:
+                tool_response = "Tool Responses:\n" + tool_response
+            messages = self.append_message_to_system(messages, tool_response)
+
+            response = self.openai_client.beta.chat.completions.parse(
+                model=self.model,
+                messages=messages,
+                response_format=schema,
+                temperature=self.temperature
+            )
+            content = response.choices[0].message.parsed
+            if isinstance(content, BaseModel):
+                content = content.model_dump(by_alias=True)
+            tokens = response.usage.total_tokens
+            
+            self.log.debug("Parse response received (tokens: %d)", tokens)
+            return content, tokens
+        except Exception as e:
+            self.log.error("Parse request failed: %s", str(e))
+            raise e
+
+    def analyze_tool_need(self, message: str, available_tools: list) -> dict:
+        """Analyze if a tool is needed for the message"""
+        prompt = make_tool_analysis_prompt(message, available_tools)
+        response = self.chat_with_model_parse([{"role": "system", "content": prompt}], schema=ToolAnalysisSchema)
+        if not response:
+            return {"tools": []}
+        return response
+
+    #! Message Alteration ---------------------------------------------------
+    def turnoff_system_message(self, messages: list):
+        # set system message to user message
+        processed = []
+        for message in messages:
+            if message["role"] == "system" or message["role"] == "developer":
+                message["role"] = "user"
+            processed.append(message)
+        return processed
+    
+    def add_message_before_system(self, messages: list, new_message: dict):
+        # add message before system message
+        processed = []
+        for message in messages:
+            if message["role"] == "system" or message["role"] == "developer":
+                processed.append(new_message)
+            processed.append(message)
+        return processed
+
+    def append_message_to_system(self, messages: list, new_message: dict):
+        # add message after system message
+        processed = []
+        for message in messages:
+            if message["role"] == "system" or message["role"] == "developer":
+                processed.append({
+                    "role": message["role"],
+                    "content": f"{message['content']}\n{new_message}"
+                })
+            else:
+                processed.append(message)
+        return processed
+    
+    #! Pipelines -----------------------------------------------------------
+    def run_steps_pipeline(self, messages: list):
+        if self.verbose:
+            p.purple("➤ Starting Steps Pipeline")
+        else:
+            self.log.info("Starting steps pipeline")
+        total_tokens = 0
+
+        messages = self.turnoff_system_message(messages)
+        steps_generator_message = messages + [{"role": "system", "content": generate_steps_prompt()}]
+
+        steps_json, tokens = self.chat_with_model_parse(steps_generator_message, schema=Steps)
+        total_tokens += tokens
+        steps = steps_json.get("steps", [])
+        if self.verbose:
+            p.yellow(f"Generated {len(steps)} steps:")
+            for idx, step in enumerate(steps, 1):
+                p.lgray(f"  {idx}. {step}")
+        else:
+            self.log.debug("Generated %d steps", len(steps))
+
+        memory = []
+
+        for idx, step in enumerate(steps, 1):
+            if self.verbose:
+                p.cyan(f"Processing step {idx}/{len(steps)}")
+            self.log.debug("Processing step %d/%d", idx, len(steps))
+            step_prompt = each_step_prompt(memory, step)
+            step_message = messages + [{"role": "system", "content": step_prompt}]
+            step_response, tokens = self.chat_with_openai_sync(step_message)
+            self.log.debug("Step %d response: %s...", idx, step_response[:100])
+            total_tokens += tokens
+            memory.append(
+                {
+                    "step": step,
+                    "answer": step_response
+                }
+            )
+
+        # Generate final conclusion
+        conclusion_prompt = generate_conclusion_prompt(memory)
+        conclusion_message = messages + [{"role": "system", "content": conclusion_prompt}]
+        conclusion, tokens = self.chat_with_openai_sync(conclusion_message)
+        total_tokens += tokens
+
+        if self.verbose:
+            p.green("✓ Steps pipeline completed")
+        
+        return {
+            "steps": memory,
+            "conclusion": conclusion
+        }, total_tokens
+
+    def run_reasoning_pipeline(self, messages: list):
+        if self.verbose:
+            p.purple(f"➤ Starting Reasoning Pipeline ({self.reasoning_iterations} iterations)")
+        else:
+            self.log.info("Starting reasoning pipeline (%d iterations)", self.reasoning_iterations)
+        total_tokens = 0
+        all_thoughts = []
+        messages = self.turnoff_system_message(messages)
+
+        for iteration in range(self.reasoning_iterations):
+            if self.verbose:
+                p.yellow(f"Iteration {iteration + 1}/{self.reasoning_iterations}")
+            self.log.debug("Iteration %d/%d", iteration + 1, self.reasoning_iterations)
+            # Generate new thoughts based on all previous thoughts
+            reasoning_message = messages + [
+                {"role": "system", "content": generate_reasoning_prompt(all_thoughts)}
+            ]
+            
+            reasoning_json, tokens = self.chat_with_model_parse(
+                reasoning_message, 
+                schema=Reasoning
+            )
+            total_tokens += tokens
+            
+            new_thoughts = reasoning_json.get("thoughts", [])
+            all_thoughts.extend(new_thoughts)
+            
+            if self.verbose:
+                p.cyan(f"Generated {len(new_thoughts)} thoughts:")
+                for idx, thought in enumerate(new_thoughts, 1):
+                    p.lgray(f"  {idx}. {thought}")
+            else:
+                self.log.debug("Generated %d new thoughts", len(new_thoughts))
+
+        return all_thoughts, total_tokens
+    
+    #! Main Chat Function ---------------------------------------------------
+    def chat(self, messages: list, schema=None):
+        """
+        Initiates a chat session with the given messages and optional schema.
+        Args:
+            messages (list): A list of message dictionaries to be processed.
+            schema (optional): A schema to parse the final output, defaults to None.
+        Returns:
+            tuple: A tuple containing the final output, total tokens used, and a details dictionary.
+                - final_output: The final response from the chat model.
+                - total_tokens (int): The total number of tokens used during the session.
+                - details_dict (dict): A dictionary with detailed information about the session, including:
+                    - "reasoning": The output from the reasoning pipeline.
+                    - "steps": The steps and conclusion from the steps pipeline.
+                    - "reasoning_tokens": The number of tokens used by the reasoning pipeline.
+                    - "steps_tokens": The number of tokens used by the steps pipeline.
+                    - "final_tokens": The number of tokens used by the final chat model.
+        """
+        if self.verbose:
+            p.blue("="*50)
+            p.blue("Starting Chat Session")
+            p.cyan(f"Messages: {len(messages)}")
+            p.cyan(f"Schema: {schema}")
+            p.blue("="*50)
+        else:
+            self.log.info("Starting chat session")
+        reasoning_output = []
+        reasoning_tokens = 0
+        steps_output = {"steps": [], "conclusion": ""}
+        steps_tokens = 0
+
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            futures = []
+            
+            if self.reasoning_pipeline:
+                futures.append({
+                    "type": "reasoning",
+                    "future": executor.submit(self.run_reasoning_pipeline, messages)
+                })
+            
+            if self.steps_pipeline:
+                futures.append({
+                    "type": "steps",
+                    "future": executor.submit(self.run_steps_pipeline, messages)
+                })
+
+            for future in futures:
+                if future["type"] == "reasoning":
+                    reasoning_output, reasoning_tokens = future["future"].result()
+                elif future["type"] == "steps":
+                    steps_output, steps_tokens = future["future"].result()
+
+        conclusion = steps_output.get("conclusion", "")
+        steps = steps_output.get("steps", [])
+
+        if self.reasoning_pipeline or self.steps_pipeline:
+            prompt = combine_all_pipeline_prompts(reasoning_output, conclusion)
+            messages = self.add_message_before_system(messages, {"role": "user", "content": prompt})
+
+        if schema:
+            final_output, tokens = self.chat_with_model_parse(messages, schema=schema)
+        else:
+            final_output, tokens = self.chat_with_openai_sync(messages)
+
+        if steps:
+            steps.append(conclusion)
+            
+        details_dict = {
+            "reasoning": reasoning_output,
+            "steps": steps,
+            "reasoning_tokens": reasoning_tokens,
+            "steps_tokens": steps_tokens,
+            "final_tokens": tokens
+        }
+        total_tokens = reasoning_tokens + steps_tokens + tokens
+        if self.verbose:
+            p.blue("="*50)
+            p.green("✓ Chat Session Completed")
+            p.yellow("Tokens Used:")
+            p.lgray(f"  - Reasoning: {reasoning_tokens}")
+            p.lgray(f"  - Steps: {steps_tokens}")
+            p.lgray(f"  - Final: {tokens}")
+            p.lgray(f"  - Total: {total_tokens}")
+            p.blue("="*50)
+        else:
+            self.log.info("Chat completed (total tokens: %d)", total_tokens)
+        return final_output, total_tokens, details_dict
+
+    #! Tools ----------------------------------------------------------------
+    def execute_tool(self, tool: str, message: str, history: list) -> dict:
+        """Execute a single tool and return its response"""
+        try:
+            self.log.debug("Executing tool: %s", tool)
+            if self.verbose:
+                p.cyan(f"\nExecuting tool: {tool}")
+                
+            if tool == "web-search":
+                response = web_search(
+                    message, 
+                    history, 
+                    self.openai_client, 
+                    self.tools_config.get("web-search", {})
+                )
+                self.log.debug("Tool %s completed successfully", tool)
+                if self.verbose:
+                    p.green(f"✓ {tool} returned response:")
+                    p.lgray("-" * 40)
+                    p.lgray(response)
+                    p.lgray("-" * 40)
+                return {
+                    "tool": tool,
+                    "response": response
+                }
+            elif tool == "calculator":
+                response = calculator(
+                    message, 
+                    history, 
+                    self.openai_client, 
+                    self.tools_config.get("calculator", {})
+                )
+                self.log.debug("Tool %s completed successfully", tool)
+                if self.verbose:
+                    p.green(f"✓ {tool} returned response:")
+                    p.lgray("-" * 40)
+                    p.lgray(response)
+                    p.lgray("-" * 40)
+                return {
+                    "tool": tool,
+                    "response": response
+                }
+            # Add other tool conditions here
+            if self.verbose:
+                p.yellow(f"! Tool {tool} not implemented")
+            return None
+        except Exception as e:
+            self.log.error("Tool %s failed: %s", tool, str(e))
+            if self.verbose:
+                p.red(f"\n✗ Tool {tool} failed: {str(e)}")
+            raise e
+
+    def batch_tools(self, tools: list, batch_size: int):
+        """Helper function to create batches of tools"""
+        iterator = iter(tools)
+        while batch := list(islice(iterator, batch_size)):
+            yield batch
+
+    def execute_tools(self, message: str, history: list) -> str:
+        """Execute tools and return formatted responses"""
+        if not self.tools:
+            return ""
+            
+        total_tools = len(self.tools)
+        self.log.info("Executing %d tools in batches of %d", total_tools, self.tool_batch_size)
+        if self.verbose:
+            p.purple(f"\n➤ Executing {total_tools} tools in batches of {self.tool_batch_size}")
+            p.yellow("Query: " + message[:100] + "..." if len(message) > 100 else message)
+            p.lgray("-" * 40)
+        
+        all_responses = []
+        success_count = 0
+        
+        for batch_idx, tool_batch in enumerate(self.batch_tools(self.tools, self.tool_batch_size), 1):
+            if self.verbose:
+                p.yellow(f"\nProcessing batch {batch_idx}...")
+            batch_responses = []
+            
+            with ThreadPoolExecutor(max_workers=min(len(tool_batch), self.tool_max_workers)) as executor:
+                future_to_tool = {
+                    executor.submit(self.execute_tool, tool, message, history): tool 
+                    for tool in tool_batch
+                }
+                
+                for future in as_completed(future_to_tool):
+                    tool = future_to_tool[future]
+                    try:
+                        result = future.result()
+                        if result:
+                            batch_responses.append(result)
+                            success_count += 1
+                    except Exception as e:
+                        if self.verbose:
+                            p.red(f"✗ Tool {tool} failed: {str(e)}")
+                        else:
+                            self.log.error("Tool %s failed: %s", tool, str(e))
+            
+            all_responses.extend(batch_responses)
+            if self.verbose:
+                p.green(f"✓ Batch {batch_idx}: {len(batch_responses)}/{len(tool_batch)} tools completed\n")
+
+        self.log.info("Tools execution completed (%d/%d successful)", success_count, total_tools)
+        if self.verbose:
+            p.green(f"\n✓ Tools execution completed ({success_count}/{total_tools} successful)")
+            
+        if not all_responses:
+            if self.verbose:
+                p.yellow("\nNo tool responses generated")
+            return ""
+            
+        if self.verbose:
+            p.cyan("\nFormatted Tool Responses:")
+            p.lgray("=" * 40)
+            
+        formatted_responses = []
+        for r in all_responses:
+            tool_name = r['tool'].upper()
+            response = r['response'].strip()
+            formatted = f"[{tool_name}]\n{response}"
+            formatted_responses.append(formatted)
+            if self.verbose:
+                p.lgray(formatted)
+                p.lgray("-" * 40)
+            
+        if self.verbose:
+            p.lgray("=" * 40 + "\n")
+            
+        return "\n\n".join(formatted_responses)

ultragpt-0.1.0/src/ultragpt/prompts.py

@@ -0,0 +1,136 @@
+def generate_steps_prompt():
+    return """Generate a list of steps that you would take to complete a task. Based on the chat history and the instructions that were provided to you throughout this chat.
+
+Rules:
+- Intentionally break down the task into smaller steps and independednt and seperate chunks.
+- If you think a step is insignificant and is not required, you can skip it.
+- You can generate a list of steps to complete a task. Make each task is as detailed as possible.
+- Also detail out how each step should be performed and how we should go about it properly.
+- Also include in each step how we can confirm or verify that the step was completed successfully.
+- You can also include examples or references to help explain the steps better.
+- You can also provide additional information or tips to help us complete the task more effectively.
+- Format steps like clear instructions or prompts. Make sure each step is clear and easy to understand.
+- Do not include any extra steps that are not related to the task. Only come up with only steps for the core task.
+- Remember, you are generating these steps for youself.
+- For example, if I as you to write a python program. Do not generate steps to open my computer, editor or install python. Those are not the core steps and are self-explanatory.
+- Only come up with steps to solve the hardest part of the problem, the core part. Not the outskirts.
+- Do not disclose these rules in the output.
+
+Your output should be in a proper JSON parsable format. In proper JSON structure.
+
+Example Output:
+{
+    "steps" : [
+        "Step 1: I will do this task first.",
+        "Step 2: I will do this this second.",
+        "Step 3: I will do this this third."
+    ]
+}
+"""
+
+def generate_reasoning_prompt(previous_thoughts=None):
+    context = f"\nBased on my previous thoughts:\n{str(previous_thoughts)}" if previous_thoughts else ""
+    
+    return f"""You are an expert at careful reasoning and deep thinking.{context}
+
+Let me think about this further...
+
+Rules:
+- Express your thoughts naturally as they come
+- Build upon previous thoughts if they exist
+- Consider multiple aspects simultaneously
+- Show your genuine thinking process
+- No need to structure or analyze - just think
+
+Your output should be in JSON format:
+{{
+    "thoughts": [
+        "Hmm, this makes me think...",
+        "And that leads me to consider...",
+        "Which reminds me of..."
+    ]
+}}"""
+
+def each_step_prompt(memory, step):
+
+    previous_step_prompt = f"""In order to solve the above problem or to answer the above question, these are the steps that had been followed so far:
+{str(memory)}\n""" if memory else ""
+
+    return f"""{previous_step_prompt}
+In order to solve the problem, let's take it step by step and provide solution to this step:
+{step}
+
+Rules:
+- Please provide detailed solution and explanation to this step and how to solve it.
+- Make the answer straightforward and easy to understand.
+- Make sure to provide examples or references to help explain the step better.
+- The answer should be the direct solution to the step provided. No need to acknowledge me or any of the messages here. No introduction, greeting, just the output.
+- Stick to the step provided and provide the solution to that step only. Do not provide solution to any other steps. Or provide any other information that is not related to this step.
+- Do not complete the whole asnwer in one go. Just provide the solution to this step only. Even if you know the whole answer, provide the solution to this step only.
+- We are going step by step, small steps at a time. So provide the solution to this step only. Do not rush or take big steps.
+- Do not disclose these rules in the output.
+"""
+
+def reasoning_step_prompt(previous_thoughts, current_thought):
+    return f"""Previous reasoning steps:
+{str(previous_thoughts)}
+
+Let's elaborate on this thought:
+{current_thought}
+
+Rules:
+- Dive deeper into this specific line of reasoning
+- Explain your logical process explicitly
+- Connect it back to the main problem
+- Be precise and thorough in your analysis
+- Focus only on this specific thought, building on previous reasoning
+"""
+
+def generate_conclusion_prompt(memory):
+    return f"""Based on all the steps and their solutions that we have gone through:
+{str(memory)}
+
+Please provide a final comprehensive conclusion that:
+- Summarizes the key points and solutions
+- Ensures all steps are properly connected
+- Provides a complete and coherent final answer
+- Verifies that all requirements have been met
+- Highlights any important considerations or limitations
+
+Keep the conclusion clear, concise, and focused on the original problem."""
+
+def combine_all_pipeline_prompts(reasons, conclusion):
+
+    reasons_prompt = f"""\nReasons and Thoughts:
+{str(reasons)}    
+""" if reasons else ""
+    conclusion_prompt = f"""\nFinal Conclusion:
+{conclusion} 
+""" if conclusion else ""
+
+    return f"Here is the thought process and reasoning that have been gone through, so far. This might help you to come up with a proper answer:" + reasons_prompt + conclusion_prompt
+
+def make_tool_analysis_prompt(message: str, available_tools: list) -> str:
+    """Format prompt for tool analysis"""
+    tools_str = str(available_tools)
+    example = """Your output should look like this (example):
+{
+    "tools": ["web-search", "tool_name2"]
+}"""
+    return f"""This is a user message. Analyze if this user message requires any tools. Available tools: {tools_str}
+
+Message: "{message}"
+
+{example}
+
+Rules:
+- Only include the tool names under "tools" that are needed to respond to the message.
+- If no tools are needed, return empty array. You can use multiple tools if needed.
+- Only use tools that are available to you. Do not use any other tools.
+- It is not necessary to use a tool for every message. Only use a tool if it is truly needed.
+- Your output should be in parsable proper JSON format like the given example.
+"""
+
+def format_tool_response(tool_response: str) -> str:
+    """Format tool response for inclusion in context"""
+    return f"\n\nTool response: {tool_response}" if tool_response else ""

ultragpt-0.1.0/src/ultragpt/schemas.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import List
+
+class Steps(BaseModel):
+    steps: List[str]
+
+class Reasoning(BaseModel):
+    thoughts: List[str]
+
+class ToolAnalysisSchema(BaseModel):
+    tools: List[str]

ultragpt-0.1.0/src/ultragpt.egg-info/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.1
+Name: ultragpt
+Version: 0.1.0
+Summary: UltraGPT: A modular library for advanced GPT-based reasoning and step pipelines
+Home-page: https://github.com/Kawai-Senpai
+Author: Ranit Bhowmick
+Author-email: bhowmickranitking@duck.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.rst
+
+# 🤖 UltraGPT
+
+**A powerful and modular library for advanced GPT-based reasoning and step pipelines**
+
+## 🌟 Features
+
+- **📝 Steps Pipeline:** Break down complex tasks into manageable steps
+  - Automatic step generation and processing
+  - Verification at each step
+  - Detailed progress tracking
+
+- **🧠 Reasoning Pipeline:** Advanced reasoning capabilities
+  - Multi-iteration thought process
+  - Building upon previous reasoning
+  - Comprehensive analysis
+
+- **🛠️ Tool Integration:** 
+  - Web search capabilities
+  - Calculator functionality
+  - Extensible tool framework
+
+## 📦 Installation
+
+```bash
+pip install git+https://github.com/Kawai-Senpai/UltraGPT.git
+```
+
+## 🚀 Quick Start
+
+```python
+from ultragpt import UltraGPT
+
+if __name__ == "__main__":
+    # Initialize UltraGPT
+    ultragpt = UltraGPT(
+        api_key="your-openai-api-key",
+        verbose=True
+    )
+
+    # Example chat session
+    final_output, tokens_used, details = ultragpt.chat([
+        {"role": "user", "content": "Write a story about an elephant."}
+    ])
+
+    print("Final Output:", final_output)
+    print("Total tokens used:", tokens_used)
+```
+
+## 📚 Advanced Usage
+
+### Customizing Pipeline Settings
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    model="gpt-4o",  # Specify model
+    temperature=0.7,  # Adjust creativity
+    reasoning_iterations=3,  # Set reasoning depth
+    steps_pipeline=True,
+    reasoning_pipeline=True,
+    verbose=True
+)
+```
+
+### Using Tools
+
+```python
+ultragpt = UltraGPT(
+    api_key="your-openai-api-key",
+    tools=["web-search", "calculator"],
+    tools_config={
+        "web-search": {
+            "max_results": 1,
+            "model": "gpt-4o"
+        },
+        "calculator": {
+            "model": "gpt-4o"
+        }
+    }
+)
+```
+
+## 🔧 Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | str | Required | Your OpenAI API key |
+| `model` | str | "gpt-4o" | Model to use |
+| `temperature` | float | 0.7 | Output randomness |
+| `reasoning_iterations` | int | 3 | Number of reasoning steps |
+| `tools` | list | [] | Enabled tools |
+| `verbose` | bool | False | Enable detailed logging |
+
+## 🌐 Tool System
+
+UltraGPT supports various tools to enhance its capabilities:
+
+### Web Search
+- Performs intelligent web searches
+- Summarizes findings
+- Integrates results into responses
+
+### Calculator
+- Handles mathematical operations
+- Supports complex calculations
+- Provides step-by-step solutions
+
+## 🔄 Pipeline System
+
+### Steps Pipeline
+1. Task Analysis
+2. Step Generation
+3. Step-by-Step Execution
+4. Progress Verification
+5. Final Compilation
+
+### Reasoning Pipeline
+1. Initial Analysis
+2. Multi-iteration Thinking
+3. Thought Development
+4. Conclusion Formation
+
+## 📋 Requirements
+
+- Python 3.6+
+- OpenAI API key
+- Internet connection (for web tools)
+
+## 🤝 Contributing
+
+Contributions are always welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/improvement`)
+3. Make changes
+4. Commit (`git commit -am 'Add new feature'`)
+5. Push (`git push origin feature/improvement`)
+6. Open a Pull Request
+
+## 📝 License
+
+This project is MIT licensed - see the [LICENSE](LICENSE) file for details.
+
+## 👥 Author
+
+**Ranit Bhowmick**
+- Email: bhowmickranitking@duck.com
+- GitHub: [@Kawai-Senpai](https://github.com/Kawai-Senpai)
+
+---
+
+<div align="center">
+Made with ❤️ by Ranit Bhowmick
+</div>

ultragpt-0.1.0/src/ultragpt.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE.rst
+MANIFEST.in
+README.md
+setup.py
+src/ultragpt/__init__.py
+src/ultragpt/core.py
+src/ultragpt/prompts.py
+src/ultragpt/schemas.py
+src/ultragpt.egg-info/PKG-INFO
+src/ultragpt.egg-info/SOURCES.txt
+src/ultragpt.egg-info/dependency_links.txt
+src/ultragpt.egg-info/requires.txt
+src/ultragpt.egg-info/top_level.txt

ultragpt-0.1.0/src/ultragpt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ultragpt-0.1.0/src/ultragpt.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pydantic
+openai
+ultraprint>=3.1.0
+tqdm
+click

ultragpt-0.1.0/src/ultragpt.egg-info/top_level.txt

@@ -0,0 +1 @@
+ultragpt