tasks-prompts-chain 0.0.6__py3-none-any.whl → 0.1.1__py3-none-any.whl

tasks_prompts_chain/client_llm_sdk.py

@@ -0,0 +1,91 @@
+class ClientLLMSDK:
+    """
+    A class to handle LLM SDKs for various providers.
+    This class is designed to work with different LLM SDKs by
+    dynamically loading the appropriate class based on the provider.
+    """
+    def __init__(self, AsyncLLmAi, model_options):
+        """
+        Initialize with any LLM SDK class.
+
+        :param llm_class: The LLM class to be used (e.g., openai.AsyncOpenAI, anthropic.AsyncAnthropic)
+        :param kwargs: Additional parameters for initializing the LLM instance
+        """
+        self.llm_class_name = AsyncLLmAi.__name__  # Store the class type
+        client_kwargs = {"api_key": model_options["api_key"]}
+        if "base_url" in model_options:
+            client_kwargs["base_url"] = model_options["base_url"]
+         # Instantiate the LLM
+        self.client = AsyncLLmAi(**client_kwargs)
+
+    async def generat_response(self, **kwargs):
+        """
+        Generate a response from the LLM.
+
+        :param prompt: The prompt to be sent to the LLM
+        :param kwargs: Additional parameters for generating the response
+        :return: The generated response
+        """
+        model = kwargs.get("model", "gpt-4")
+        messages= kwargs.get("messages", [])
+        temperature = kwargs.get("temperature", 0.7)
+        max_tokens = kwargs.get("max_tokens", 512)
+        stream = kwargs.get("stream", True)
+        
+        if self.llm_class_name == "AsyncOpenAI":  # OpenAI SDK
+            response = await self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=stream
+            )
+            
+            async for chunk in response:
+                if chunk.choices[0].delta.content is not None:
+                    yield chunk.choices[0].delta.content
+                
+
+        elif self.llm_class_name == "AsyncAnthropic":  # Anthropic SDK
+            # Extract system message if present
+            system_message = ""
+            filtered_messages = []
+            
+            for message in messages:
+                if message.get("role") == "system" and message.get("content") != None:
+                    system_message = message.get("content")
+                else:
+                    filtered_messages.append(message)
+            
+            # Update messages without system message
+            messages = filtered_messages
+            response = await self.client.messages.create(
+                system=system_message,
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=stream
+            )
+            
+            async for chunk in response:
+                # Based on the observed output format: RawContentBlockDeltaEvent with TextDelta
+                if chunk.type == "content_block_delta" and hasattr(chunk.delta, "text"):
+                    yield chunk.delta.text
+                elif chunk.type == "content_block_stop":
+                    pass
+        
+        elif self.llm_class_name == "AsyncCerebras":  # AsyncCerebras SDK
+            response = await self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=stream
+            )
+            
+            async for chunk in response:
+                if chunk.choices[0].delta.content is not None:
+                    yield chunk.choices[0].delta.content
+        else:
+            raise NotImplementedError(f"Unsupported LLM: {self.llm_class_name}")

tasks_prompts_chain/tasks_prompts_chain.py

@@ -29,8 +29,9 @@ Copyright 2025 Samir Ben Sghaier - Smirfolio
 
 """
 from typing import List, Optional, Dict, Union, AsyncGenerator, TypedDict
-from openai import AsyncOpenAI
 from enum import Enum
+from .client_llm_sdk import ClientLLMSDK
+import json
 
 class OutputFormat(Enum):
     JSON = "JSON"
@@ -44,46 +45,74 @@ class ModelOptions(TypedDict, total=False):
     base_url: Optional[str]
     temperature: Optional[float]
     max_tokens: Optional[int]
-    stream: Optional[bool]
 
 class PromptTemplate:
-    def __init__(self, prompt: str, output_format: str = "TEXT", output_placeholder: Optional[str] = None):
+    def __init__(self, prompt: str, output_format: str = "TEXT", output_placeholder: Optional[str] = None, llm_id: Optional[str] = None, stop_placeholder: Optional[str] = None):
         self.prompt = prompt
-        self.output_format = OutputFormat(output_format.upper()).value
+        self.output_format = OutputFormat(output_format.upper())
         self.output_placeholder = output_placeholder
+        self.llm_id=llm_id
+        self.stop_placeholder = stop_placeholder
 
 class TasksPromptsChain:
     """A utility class for creating and executing prompt chains using OpenAI's API."""
     
-    def __init__(self, 
-                 model_options: ModelOptions,
+    def __init__(self,
+                 llm_configs: List[Dict],
                  system_prompt: Optional[str] = None,
                  final_result_placeholder: Optional[str] = None,
                  system_apply_to_all_prompts: bool = False):
         """
-        Initialize the TasksPromptsChain with OpenAI configuration.
+        Initialize the TasksPromptsChain with multiple LLM configurations.
         
         Args:
-            model_options (ModelOptions): Dictionary containing model configuration:
-                - model (str): The model identifier to use (e.g., 'gpt-3.5-turbo')
-                - api_key (str): The OpenAI API key
-                - base_url (str, optional): API endpoint URL
-                - temperature (float, optional): Temperature parameter (default: 0.7)
-                - max_tokens (int, optional): Maximum tokens (default: 4120)
-                - stream (bool, optional): Whether to stream responses (default: True)
+            llm_configs (List[Dict]): List of LLM configurations, each containing:
+                - llm_id (str): Unique identifier for this LLM configuration
+                - llm_class: The LLM class to use (e.g., openai.AsyncOpenAI, anthropic.AsyncAnthropic)
+                - model_options (Dict): Configuration for the LLM:
+                    - model (str): The model identifier to use
+                    - api_key (str): API key
+                    - base_url (str, optional): Custom API endpoint URL
+                    - temperature (float, optional): Temperature parameter (default: 0.7)
+                    - max_tokens (int, optional): Maximum tokens (default: 4120)
             system_prompt (str, optional): System prompt to set context for the LLM
             final_result_placeholder (str, optional): The placeholder name for the final result
             system_apply_to_all_prompts (bool): Whether to apply system prompt to all prompts
         """
-        self.model = model_options["model"]
-        self.temperature = model_options.get("temperature", 0.7)
-        self.max_tokens = model_options.get("max_tokens", 4120)
-        self.stream = model_options.get("stream", True)
+        # Initialize clients dictionary
+        self.clients = {}
+        self.default_client_id = None
         
-        client_kwargs = {"api_key": model_options["api_key"]}
-        if "base_url" in model_options:
-            client_kwargs["base_url"] = model_options["base_url"]
-        self.client = AsyncOpenAI(**client_kwargs)
+        # Set up each LLM client
+        for config in llm_configs:
+            llm_id = config.get("llm_id")
+            if not llm_id:
+                raise ValueError("Each LLM configuration must have a 'llm_id'")
+                
+            llm_class = config.get("llm_class")
+            if not llm_class:
+                raise ValueError(f"LLM configuration '{llm_id}' must specify 'llm_class'")
+                
+            model_options = config.get("model_options", {})
+            if "api_key" not in model_options:
+                raise ValueError(f"LLM configuration '{llm_id}' must include 'api_key' in model_options")
+            
+            # Set the first client as default if not already set
+            if self.default_client_id is None:
+                self.default_client_id = llm_id
+            
+            # Store common settings in the client record for easy access
+            client_kwargs = {"api_key": model_options["api_key"]}
+            if "base_url" in model_options:
+                client_kwargs["base_url"] = model_options["base_url"]
+                
+            self.clients[llm_id] = {
+                "llm_id": llm_id,
+                "model": model_options.get("model", "gpt-3.5-turbo"),
+                "temperature": model_options.get("temperature", 0.7),
+                "max_tokens": model_options.get("max_tokens", 4120),
+                "client": ClientLLMSDK(llm_class, client_kwargs)
+            }
         self.system_prompt = system_prompt
         self.system_apply_to_all_prompts = system_apply_to_all_prompts
         self.final_result_placeholder = final_result_placeholder or "final_result"
@@ -91,7 +120,15 @@ class TasksPromptsChain:
         self._output_template = None
         self._final_output_template = None
         self._current_stream_buffer = ""
-
+    
+    def get_reflection(self):
+        """
+        Get the reflection of the class instance with available LLM clients.
+        
+        Returns:
+            dict: Dictionary of available LLM clients and their IDs
+        """
+        return {llm_id: config["client"].llm_class_name for llm_id, config in self.clients.items()}
     def set_output_template(self, template: str) -> None:
         """
         Set the output template to be used for streaming responses.
@@ -121,7 +158,7 @@ class TasksPromptsChain:
         self._final_output_template=output
         return output
 
-    async def execute_chain(self, prompts: List[Union[Dict, PromptTemplate]]) -> AsyncGenerator[str, None]:
+    async def execute_chain(self, prompts: List[Union[Dict, PromptTemplate]], streamout = True) -> AsyncGenerator[str, None]:
         """
         Execute a chain of prompts sequentially, with placeholder replacement.
         
@@ -130,87 +167,89 @@ class TasksPromptsChain:
                                                         {
                                                             "prompt": str,
                                                             "output_format": str,
-                                                            "output_placeholder": str
+                                                            "output_placeholder": str,
+                                                            "llm_id": str,  # Optional: Specifies which LLM to use
+                                                            "stop_placeholder": str  # Optional: The stop string placeholder
                                                         }
         Returns:
-            List[str]: List of responses for each prompt
+            AsyncGenerator[str, None]: Generator yielding response chunks
         """
         responses = []
         placeholder_values = {}
 
         try:
             for i, prompt_data in enumerate(prompts):
-                # Convert dict to PromptTemplate if necessary
+                # Convert dict to PromptTemplate if necessary and extract llm_id
+                llm_id = None
                 if isinstance(prompt_data, dict):
                     prompt_template = PromptTemplate(
                         prompt=prompt_data["prompt"],
                         output_format=prompt_data.get("output_format", "TEXT"),
-                        output_placeholder=prompt_data.get("output_placeholder")
+                        output_placeholder=prompt_data.get("output_placeholder"),
+                        llm_id= prompt_data.get("llm_id", self.default_client_id),
+                        stop_placeholder=prompt_data.get("stop_placeholder", None)
                     )
                 else:
                     prompt_template = prompt_data
+                
+                # Validate the requested LLM exists
+                if prompt_template.llm_id not in self.clients:
+                    raise ValueError(f"LLM with id '{prompt_template.llm_id}' not found. Available LLMs: {list(self.clients.keys())}")
+                
+                # Get the client configuration
+                client_config = self.clients[prompt_template.llm_id]
+                client = client_config["client"]
+                model = client_config["model"]
+                temperature = client_config["temperature"]
+                max_tokens = client_config["max_tokens"]
 
                 # Replace placeholders in the prompt
                 current_prompt = prompt_template.prompt
                 for placeholder, value in placeholder_values.items():
                     current_prompt = current_prompt.replace(f"{{{{{placeholder}}}}}", value)
 
-                wants_json_output = prompt_template.output_format == OutputFormat.JSON.value
                 # Format system message based on output format
                 format_instruction = ""
-                if wants_json_output:
-                    format_instruction = f"\nPlease provide your response in {prompt_template.output_format}."                    
+                if prompt_template.output_format != OutputFormat.TEXT:
+                    format_instruction = f"\nPlease provide your response in {prompt_template.output_format.value} format."
 
                 messages = []
                 if self.system_prompt and (i == 0 or self.system_apply_to_all_prompts):
                     messages.append({"role": "system", "content": self.system_prompt})
-                
+
                 messages.append({"role": "user", "content": current_prompt + format_instruction})
                 
-                # Default completition.create parameters
-                create_kwargs = {
-                    "model": self.model,
-                    "messages": messages,
-                    "temperature": self.temperature,
-                    "max_tokens": self.max_tokens,
-                    "stream": self.stream
-                }
-
-                # Check if used model is GPT 
-                is_gpt_model = self.model.lower().startswith("gpt")
-                # GPT model text = {"format" : {"type": "json_object"}}
-                if is_gpt_model and wants_json_output:
-                    create_kwargs["text"] = {
-                        "format": {
-                                "type": "json_object"
-                        }
-                    }
-
-                # Non Gpt model response_format={"type": "json_object|text"}
-                elif not is_gpt_model:
-                    create_kwargs["response_format"] = {
-                        "type": "json_object" if wants_json_output else "text"
-                    }
-
-                stream = await self.client.chat.completions.create(**create_kwargs)
+                # Generate response using the selected LLM
+                streamResponse = client.generat_response(
+                    model=model,
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    stream=True
+                )
                 
                 response_content = ""
                 self._current_stream_buffer = ""
                 
-                async for chunk in stream:
-                    if not chunk.choices or not chunk.choices[0].delta or not chunk.choices[0].delta.content:
-                        continue
-
-                    delta = chunk.choices[0].delta.content
-                    response_content += delta
-                    self._current_stream_buffer = response_content
-                    self._format_current_stream()
-                    responses.append(response_content)
-                    # Store response with placeholder if specified
-                    if prompt_template.output_placeholder:
-                        placeholder_values[prompt_template.output_placeholder] = response_content
-                        self._results[prompt_template.output_placeholder] = response_content
-                    yield delta              
+                async for chunk in streamResponse:
+                    if chunk is not None:
+                        delta = chunk
+                        response_content += delta
+                        self._current_stream_buffer = response_content
+                        self._format_current_stream()
+                        responses.append(response_content)
+                        # Store response with placeholder if specified
+                        if prompt_template.output_placeholder:
+                            placeholder_values[prompt_template.output_placeholder] = response_content
+                            self._results[prompt_template.output_placeholder] = response_content
+                        if streamout:
+                            yield delta
+                
+                # Stop excution if the stop_placeholder is detected in the response content
+                if prompt_template.stop_placeholder and (prompt_template.stop_placeholder in response_content):
+                    raise Exception({"type": "error", "content": "Invalid project description. Please provide a valid project description."})
+                    #yield json.dumps({"type": "error", "content": "Invalid project description. Please provide a valid project description."})
+                    #return          
 
         except Exception as e:
             raise Exception(f"Error in prompt chain execution at prompt {i}: {str(e)}")
@@ -218,6 +257,7 @@ class TasksPromptsChain:
         # Store the last response with the final result placeholder
         if responses:
             self._results[self.final_result_placeholder] = responses[-1]
+            yield "<tasks-sys>Done</tasks-sys>"
 
     def get_result(self, placeholder: str) -> Optional[str]:
         """
@@ -253,4 +293,3 @@ class TasksPromptsChain:
         if len(self._results) > 0:
             raise Exception("template_output must be called before execute_chain")
         self.set_output_template(template)
-

tasks_prompts_chain-0.1.1.dist-info/METADATA

@@ -0,0 +1,412 @@
+Metadata-Version: 2.4
+Name: tasks_prompts_chain
+Version: 0.1.1
+Summary: A Python library for creating and executing chains of prompts using multiple LLM providers with streaming support and template formatting.
+Project-URL: Homepage, https://github.com/smirfolio/tasks_prompts_chain
+Project-URL: Issues, https://github.com/smirfolio/tasks_prompts_chain/issues
+Author-email: Samir Ben Sghaier <ben.sghaier.samir@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# TasksPromptsChain
+
+A Mini Python library for creating and executing chains of prompts using multiple LLM providers with streaming support and output template formatting.
+
+## Features
+
+- Sequential prompt chain execution
+- Streaming responses
+- Template-based output formatting
+- System prompt support
+- Placeholder replacement between prompts
+- Stop placeholder string, that can be defined, so if the LLM responds with this placeholder, the chain prompt will interrupt, as an LLM error handler
+- Multiple output formats (JSON, Markdown, CSV, Text)
+- Async/await support
+- Support for multiple LLM providers (OpenAI, Anthropic, Cerebras, etc.)
+- Multi-model support - use different models for different prompts in the chain
+
+## Dependencies
+
+Please install typing-extensions and the SDK for your preferred LLM providers:
+
+For OpenAI:
+```bash
+pip install typing-extensions
+pip install openai
+```
+
+For Anthropic:
+```bash
+pip install typing-extensions
+pip install anthropic
+```
+
+For Cerebras:
+```bash
+pip install typing-extensions
+pip install cerebras
+```
+
+To Install the library: 
+```
+pip install tasks_prompts_chain
+```
+
+## Installation from source code
+
+### For Users required from source gitHub repo
+```bash
+pip install -r requirements/requirements.txt
+```
+
+### For Developers required from source gitHub repo
+```bash
+pip install -r requirements/requirements.txt
+pip install -r requirements/requirements-dev.txt
+```
+
+## Quick Start
+
+```python
+from tasks_prompts_chain import TasksPromptsChain
+from openai import AsyncOpenAI
+from anthropic import AsyncAnthropic
+from cerebras import AsyncCerebras
+
+async def main():
+    # Initialize the chain with multiple LLM configurations
+    llm_configs = [
+        {
+            "llm_id": "gpt",  # Unique identifier for this LLM
+            "llm_class": AsyncOpenAI,  # LLM SDK class
+            "model_options": {
+                "model": "gpt-4o",
+                "api_key": "your-openai-api-key",
+                "temperature": 0.1,
+                "max_tokens": 4120,
+            }
+        },
+        {
+            "llm_id": "claude",  # Unique identifier for this LLM
+            "llm_class": AsyncAnthropic,  # LLM SDK class
+            "model_options": {
+                "model": "claude-3-sonnet-20240229",
+                "api_key": "your-anthropic-api-key",
+                "temperature": 0.1,
+                "max_tokens": 8192,
+            }
+        },
+        {
+            "llm_id": "llama",  # Unique identifier for this LLM
+            "llm_class": AsyncCerebras,  # LLM SDK class
+            "model_options": {
+                "model": "llama-3.3-70b",
+                "api_key": "your-cerebras-api-key",
+                "base_url": "https://api.cerebras.ai/v1",
+                "temperature": 0.1,
+                "max_tokens": 4120,
+            }
+        }
+    ]
+
+    chain = TasksPromptsChain(
+        llm_configs,
+        final_result_placeholder="design_result"
+    )
+
+    # Define your prompts - specify which LLM to use for each prompt
+    prompts = [
+        {
+            "prompt": "Create a design concept for a luxury chocolate bar, if not inspired respond with this string %%cant_be_inspired%% so the chain prompt query will be stopped",
+            "output_format": "TEXT",
+            "output_placeholder": "design_concept",
+            "llm_id": "gpt",  # Use the GPT model for this prompt
+            "stop_placholder": "%%cant_be_inspired%%" # the stop placeholder string that will interrupt the prompt chain query
+        },
+        {
+            "prompt": "Based on this concept: {{design_concept}}, suggest a color palette",
+            "output_format": "JSON",
+            "output_placeholder": "color_palette",
+            "llm_id": "claude"  # Use the Claude model for this prompt
+        },
+        {
+            "prompt": "Based on the design and colors: {{design_concept}} and {{color_palette}}, suggest packaging materials",
+            "output_format": "MARKDOWN",
+            "output_placeholder": "packaging",
+            "llm_id": "llama"  # Use the Cerebras model for this prompt
+        }
+    ]
+
+    # Stream the responses
+    async for chunk in chain.execute_chain(prompts):
+        print(chunk, end="", flush=True)
+
+    # Get specific results
+    design = chain.get_result("design_concept")
+    colors = chain.get_result("color_palette")
+    packaging = chain.get_result("packaging")
+```
+
+## Advanced Usage
+
+### Using System Prompts
+
+```python
+chain = TasksPromptsChain(
+    llm_configs=[
+        {
+            "llm_id": "default_model",
+            "llm_class": AsyncOpenAI,
+            "model_options": {
+                "model": "gpt-4o",
+                "api_key": "your-openai-api-key",
+                "temperature": 0.1,
+                "max_tokens": 4120,
+            }
+        }
+    ],
+    final_result_placeholder="result",
+    system_prompt="You are a professional design expert specialized in luxury products",
+    system_apply_to_all_prompts=True
+)
+```
+
+### Using Cerebras Models
+
+```python
+from cerebras import AsyncCerebras
+
+llm_configs = [
+    {
+        "llm_id": "cerebras",
+        "llm_class": AsyncCerebras,
+        "model_options": {
+            "model": "llama-3.3-70b",
+            "api_key": "your-cerebras-api-key",
+            "base_url": "https://api.cerebras.ai/v1",
+            "temperature": 0.1,
+            "max_tokens": 4120,
+        }
+    }
+]
+
+chain = TasksPromptsChain(
+    llm_configs,
+    final_result_placeholder="result",
+)
+```
+
+### Custom API Endpoint
+
+```python
+llm_configs = [
+    {
+        "llm_id": "custom_endpoint",
+        "llm_class": AsyncOpenAI,
+        "model_options": {
+            "model": "your-custom-model",
+            "api_key": "your-api-key",
+            "base_url": "https://your-custom-endpoint.com/v1",
+            "temperature": 0.1,
+            "max_tokens": 4120,
+        }
+    }
+]
+
+chain = TasksPromptsChain(
+    llm_configs,
+    final_result_placeholder="result",
+)
+```
+
+### Using Templates
+
+You must call this set method before the execution of the prompting query (chain.execute_chain(prompts))
+
+```python
+# Set output template before execution
+chain.template_output("""
+<result>
+    <design>
+    ### Design Concept:
+    {{design_concept}}
+    </design>
+    
+    <colors>
+    ### Color Palette:
+    {{color_palette}}
+    </colors>
+</result>
+""")
+```
+then retrieves the final result within the template : 
+
+```python
+# print out the final result in the well formated template
+print(chain.get_final_result_within_template())
+```
+
+
+## API Reference
+
+### TasksPromptsChain Class
+
+#### Constructor Parameters
+
+- `llm_configs` (List[Dict]): List of LLM configurations, each containing:
+  - `llm_id` (str): Unique identifier for this LLM configuration
+  - `llm_class`: The LLM class to use (e.g., `AsyncOpenAI`, `AsyncAnthropic`, `AsyncCerebras`)
+  - `model_options` (Dict): Configuration for the LLM:
+    - `model` (str): The model identifier
+    - `api_key` (str): Your API key for the LLM provider
+    - `temperature` (float): Temperature setting for response generation
+    - `max_tokens` (int): Maximum tokens in generated responses
+    - `base_url` (Optional[str]): Custom API endpoint URL
+- `system_prompt` (Optional[str]): System prompt for context
+- `final_result_placeholder` (str): Name for the final result placeholder
+- `system_apply_to_all_prompts` (Optional[bool]): Apply system prompt to all prompts
+
+#### Methods
+
+- `execute_chain(prompts: List[Dict], streamout: bool = True) -> AsyncGenerator[str, None]`
+  - Executes the prompt chain and streams responses
+  
+- `template_output(template: str) -> None`
+  - Sets the output template format
+  
+- `get_final_result_within_template(self) -> Optional[str]`
+  - Retrieves the final query result with the defined template in template_output();
+
+- `get_result(placeholder: str) -> Optional[str]`
+  - Retrieves a specific result by placeholder
+
+### Prompt Format
+
+Each prompt in the chain can be defined as a dictionary:
+```python
+{
+    "prompt": str,              # The actual prompt text
+    "output_format": str,       # "JSON", "MARKDOWN", "CSV", or "TEXT"
+    "output_placeholder": str,  # Identifier for accessing this result
+    "llm_id": str,              # Optional: ID of the LLM to use for this prompt
+    "stop_placholder": str      # Optional: The stop string placeholder that may interrupt the chaining prompt query, defined in a prompt, and may be returned by the LLM
+}
+```
+
+## Supported LLM Providers
+
+TasksPromptsChain currently supports the following LLM providers:
+
+1. **OpenAI** - via `AsyncOpenAI` from the `openai` package
+2. **Anthropic** - via `AsyncAnthropic` from the `anthropic` package
+3. **Cerebras** - via `AsyncCerebras` from the `cerebras` package
+
+Each provider has different capabilities and models. The library adapts the API calls to work with each provider's specific requirements.
+
+## Error Handling
+
+The library includes comprehensive error handling:
+- Template validation
+- API error handling
+- Placeholder validation
+- LLM validation (checks if specified LLM ID exists)
+- stop_placholder to validate the LLM output and stop the chain prompt excution
+
+Errors are raised with descriptive messages indicating the specific issue and prompt number where the error occurred.
+
+## Best Practices
+
+1. Always set templates before executing the chain
+2. Use meaningful placeholder names
+3. Implement a stop_placholder in each prompt, to catch the LLM error defined bad responses to stop the subsequent requests
+3. Handle streaming responses appropriately
+4. Choose appropriate models for different types of tasks
+5. Use system prompts for consistent context
+6. Select the best provider for specific tasks:
+   - OpenAI is great for general purpose applications
+   - Anthropic (Claude) excels at longer contexts and complex reasoning
+   - Cerebras is excellent for high-performance AI tasks
+
+## How You Can Get Involved
+✅ Try out tasks_prompts_chain: Give our software a try in your own setup and let us know how it goes - your experience helps us improve!
+
+✅ Find a bug: Found something that doesn't work quite right? We'd appreciate your help in documenting it so we can fix it together.
+
+✅ Fixing Bugs: Even small code contributions make a big difference! Pick an issue that interests you and share your solution with us.
+
+✅ Share your thoughts: Have an idea that would make this project more useful? We're excited to hear your thoughts and explore new possibilities together!
+
+Your contributions, big or small, truly matter to us. We're grateful for any help you can provide and look forward to welcoming you to our community!
+
+### Developer Contribution Workflow
+1. Fork the Repository: Create your own copy of the project by clicking the "Fork" button on our GitHub repository.
+2. Clone Your Fork: 
+``` bash
+git clone git@github.com:<your-username>/tasks_prompts_chain.git
+cd tasks_prompts_chain/
+```
+3. Set Up Development Environment
+``` bash
+# Create and activate a virtual environment
+python3 -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install development dependencies
+pip install -r requirements/requirements-dev.txt
+```
+4. Stay Updated
+```bash
+# Add the upstream repository
+git remote add upstream https://github.com/original-owner/tasks_prompts_chain.git
+
+# Fetch latest changes from upstream
+git fetch upstream
+git merge upstream/main
+```
+#### Making Changes
+1. Create a Feature Branch
+```bash
+git checkout -b feature/your-feature-name
+# or
+git checkout -b bugfix/issue-you-are-fixing
+```
+2. Implement Your Changes
+    - Write tests for your changes when applicable
+    - Ensure existing tests pass with pytest
+    - Follow our code style guidelines
+
+3. Commit Your Changes
+```bash
+git add .
+git commit -m "Your descriptive commit message"
+```
+4. Push to Your Fork
+```bash
+git push origin feature/your-feature-name
+```
+5. Create a Pull Request
+6. Code Review Process
+    - Maintainers will review your PR
+    - Address any requested changes
+    - Once approved, your contribution will be merged!
+
+## Release Notes
+
+### 0.1.0 - Breaking Changes
+
+- **Complete API redesign**: The constructor now requires a list of LLM configurations instead of a single LLM class
+- **Multi-model support**: Use different models for different prompts in the chain
+- **Constructor changes**: Replaced `AsyncLLmAi` and `model_options` with `llm_configs`
+- **New provider support**: Added official support for Cerebras models
+- **Removed dependencies**: No longer directly depends on OpenAI SDK
+- **Prompt configuration**: Added `llm_id` field to prompt dictionaries to specify which LLM to use
+
+Users upgrading from version 0.0.x will need to modify their code to use the new API structure.
+
+## License
+
+MIT License

tasks_prompts_chain-0.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+tasks_prompts_chain/__init__.py,sha256=HVhC_vMTYCyZW6vnoErHh-TkAnNRqJ2JJqClJQSfU8Y,148
+tasks_prompts_chain/client_llm_sdk.py,sha256=ifwsecvykP5RalXMqolAClPHdpmv-5hF4eT61dxo1f8,3708
+tasks_prompts_chain/tasks_prompts_chain.py,sha256=T8WaqAdgDBqHjNa48dPgny_mDnEN1OvMTFTX6YndGgo,13409
+tasks_prompts_chain-0.1.1.dist-info/METADATA,sha256=1zVlU2deVaP-Fv_Zj6ph6LcDJrJOD4qSffehnp1umRM,13331
+tasks_prompts_chain-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tasks_prompts_chain-0.1.1.dist-info/licenses/LICENSE,sha256=WYmcYJG1QFgu1hfo7qrEkZ3Jhcz8NUWe6XUraZvlIFs,10172
+tasks_prompts_chain-0.1.1.dist-info/RECORD,,

tasks_prompts_chain-0.0.6.dist-info/METADATA

@@ -1,222 +0,0 @@
-Metadata-Version: 2.4
-Name: tasks_prompts_chain
-Version: 0.0.6
-Summary: A Python library for creating and executing chains of prompts using OpenAI's SDK with streaming support and template formatting.
-Project-URL: Homepage, https://github.com/smirfolio/tasks_prompts_chain
-Project-URL: Issues, https://github.com/smirfolio/tasks_prompts_chain/issues
-Author-email: Samir Ben Sghaier <ben.sghaier.samir@gmail.com>
-License-Expression: Apache-2.0
-License-File: LICENSE
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# TasksPromptsChain
-
-A Mini Python library for creating and executing chains of prompts using OpenAI's API with streaming support and output template formatting.
-
-## Features
-
-- Sequential prompt chain execution
-- Streaming responses
-- Template-based output formatting
-- System prompt support
-- Placeholder replacement between prompts
-- Multiple output formats (JSON, Markdown, CSV, Text)
-- Async/await support
-
-## Dependancies
-
-Please install typing-extensions and openai python packages
-```bash
-pip install typing-extensions
-pip install openai
-```
-To Install the library: 
-```
-pip install tasks_prompts_chain
-```
-
-## Installation from source code
-
-### For Users required from source gitHub repo
-```bash
-pip install -r requirements/requirements.txt
-```
-
-### For Developers required from source gitHub repo
-```bash
-pip install -r requirements/requirements.txt
-pip install -r requirements/requirements-dev.txt
-```
-
-## Quick Start
-
-```python
-from tasks_prompts_chain import TasksPromptsChain
-
-async def main():
-    # Initialize the chain
-    chain = TasksPromptsChain(
-        model_options={
-            "model": "gpt-3.5-turbo",
-            "api_key": "your-api-key",
-            "temperature": 0.1,
-            "max_tokens": 4120,
-            "stream": True
-        },
-        final_result_placeholder="design_result"
-    )
-
-    # Define your prompts
-    prompts = [
-        {
-            "prompt": "Create a design concept for a luxury chocolate bar",
-            "output_format": "TEXT",
-            "output_placeholder": "design_concept"
-        },
-        {
-            "prompt": "Based on this concept: {{design_concept}}, suggest a color palette",
-            "output_format": "JSON",
-            "output_placeholder": "color_palette"
-        }
-    ]
-
-    # Stream the responses
-    async for chunk in chain.execute_chain(prompts):
-        print(chunk, end="", flush=True)
-
-    # Get specific results
-    design = chain.get_result("design_concept")
-    colors = chain.get_result("color_palette")
-```
-
-## Advanced Usage
-
-### Using System Prompts
-
-```python
-chain = TasksPromptsChain(
-    model_options={
-            "model": "gpt-3.5-turbo",
-            "api_key": "your-api-key",
-            "temperature": 0.1,
-            "max_tokens": 4120,
-            "stream": True
-        },
-    final_result_placeholder="result",
-    system_prompt="You are a professional design expert specialized in luxury products",
-    system_apply_to_all_prompts=True
-)
-```
-
-### Custom API Endpoint
-
-```python
-chain = TasksPromptsChain(
-    model_options={
-            "model": "your-custom-model",
-            "api_key": "your-api-key",
-            "base_url": "https://your-custom-endpoint.com/v1",
-            "temperature": 0.1,
-            "max_tokens": 4120,
-            "stream": True
-        },
-    final_result_placeholder="result",
-)
-```
-
-### Using Templates
-
-You must call this set method befor the excution of the prompting query (chain.execute_chain(prompts))
-
-```python
-# Set output template before execution
-chain.template_output("""
-<result>
-    <design>
-    ### Design Concept:
-    {{design_concept}}
-    </design>
-    
-    <colors>
-    ### Color Palette:
-    {{color_palette}}
-    </colors>
-</result>
-""")
-```
-then retrieves the final result within the template : 
-
-```python
-# print out the final result in the well formated template
-print(chain.get_final_result_within_template())
-```
-
-
-## API Reference
-
-### TasksPromptsChain Class
-
-#### Constructor Parameters
-
-- `model` (str): The model identifier (e.g., 'gpt-3.5-turbo')
-- `api_key` (str): Your OpenAI API key
-- `final_result_placeholder` (str): Name for the final result placeholder
-- `system_prompt` (Optional[str]): System prompt for context
-- `system_apply_to_all_prompts` (Optional[bool]): Apply system prompt to all prompts
-- `base_url` (Optional[str]): Custom API endpoint URL
-
-#### Methods
-
-- `execute_chain(prompts: List[Dict], temperature: float = 0.7) -> AsyncGenerator[str, None]`
-  - Executes the prompt chain and streams responses
-  
-- `template_output(template: str) -> None`
-  - Sets the output template format
-  
-- `get_final_result_within_template(self) -> Optional[str]`
-  - Retrieves the final query result with the defined template in template_output();
-
-- `get_result(placeholder: str) -> Optional[str]`
-  - Retrieves a specific result by placeholder
-
-### Prompt Format
-
-Each prompt in the chain can be defined as a dictionary:
-```python
-{
-    "prompt": str,           # The actual prompt text
-    "output_format": str,    # "JSON", "MARKDOWN", "CSV", or "TEXT"
-    "output_placeholder": str # Identifier for accessing this result
-}
-```
-
-## Error Handling
-
-The library includes comprehensive error handling:
-- Template validation
-- API error handling
-- Placeholder validation
-
-Errors are raised with descriptive messages indicating the specific issue and prompt number where the error occurred.
-
-## Best Practices
-
-1. Always set templates before executing the chain
-2. Use meaningful placeholder names
-3. Handle streaming responses appropriately
-4. Consider temperature settings based on your use case
-5. Use system prompts for consistent context
-
-## Compatible Models
-
-- Llama3.3
-- llama-4-scout
-- claude-3-7-sonnet-20250219 (Other claude version)
-- ChatGpt's
-
-## License
-
-MIT License

tasks_prompts_chain-0.0.6.dist-info/RECORD

@@ -1,6 +0,0 @@
-tasks_prompts_chain/__init__.py,sha256=HVhC_vMTYCyZW6vnoErHh-TkAnNRqJ2JJqClJQSfU8Y,148
-tasks_prompts_chain/tasks_prompts_chain.py,sha256=DUKe5PseHKA9ownVXQpawcdAKGcwHvHtx1U_st2hT_8,10924
-tasks_prompts_chain-0.0.6.dist-info/METADATA,sha256=RNClygTof_WT8IryvMw4SeoVgWZeMYSKY5SlfLUwk4I,5892
-tasks_prompts_chain-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tasks_prompts_chain-0.0.6.dist-info/licenses/LICENSE,sha256=WYmcYJG1QFgu1hfo7qrEkZ3Jhcz8NUWe6XUraZvlIFs,10172
-tasks_prompts_chain-0.0.6.dist-info/RECORD,,