From a77e81faadf686f0e54dd9d868372217a89428bd Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Tue, 29 Jul 2025 17:03:47 -0700 Subject: [PATCH 01/10] Integrating the Re-prompting pipeline into the SDK --- aimon/reprompting_api/_init_.py | 0 aimon/reprompting_api/config.py | 59 ++ aimon/reprompting_api/pipeline.py | 543 ++++++++++++++++++ aimon/reprompting_api/reprompter.py | 218 +++++++ aimon/reprompting_api/runner.py | 76 +++ aimon/reprompting_api/telemetry.py | 75 +++ aimon/reprompting_api/tests/_init_.py | 0 .../tests/test_reprompting_cases.py | 172 ++++++ .../tests/test_reprompting_failures.py | 123 ++++ .../tests/test_reprompting_success.py | 106 ++++ aimon/reprompting_api/utils.py | 185 ++++++ 11 files changed, 1557 insertions(+) create mode 100644 aimon/reprompting_api/_init_.py create mode 100644 aimon/reprompting_api/config.py create mode 100644 aimon/reprompting_api/pipeline.py create mode 100644 aimon/reprompting_api/reprompter.py create mode 100644 aimon/reprompting_api/runner.py create mode 100644 aimon/reprompting_api/telemetry.py create mode 100644 aimon/reprompting_api/tests/_init_.py create mode 100644 aimon/reprompting_api/tests/test_reprompting_cases.py create mode 100644 aimon/reprompting_api/tests/test_reprompting_failures.py create mode 100644 aimon/reprompting_api/tests/test_reprompting_success.py create mode 100644 aimon/reprompting_api/utils.py diff --git a/aimon/reprompting_api/_init_.py b/aimon/reprompting_api/_init_.py new file mode 100644 index 0000000..e69de29 diff --git a/aimon/reprompting_api/config.py b/aimon/reprompting_api/config.py new file mode 100644 index 0000000..ba2bae8 --- /dev/null +++ b/aimon/reprompting_api/config.py @@ -0,0 +1,59 @@ +import os +from typing import Optional +from dataclasses import dataclass +import random +import string + +def generate_random_string(length: int) -> str: + """Generates a random string of letters and digits.""" + if not isinstance(length, int) or length <= 0: + raise ValueError("Length must be a positive integer.") + characters = string.ascii_letters + string.digits + return ''.join(random.choice(characters) for i in range(length)) + +class StopReasons: + ALL_INSTRUCTIONS_ADHERED = "all_instructions_adhered" + MAX_ITERATIONS_REACHED = "max_iterations_reached" + CONTINUE = "instructions_failed_continue_reprompting" + CONTINUE_TOXICITY = "toxicity_detect_continue_reprompting" + + ## limits + LATENCY_LIMIT_EXCEEDED = "latency_limit_exceeded" + + ##errors + REPROMPTING_FAILED = "reprompting_failed" + UNKNOWN_ERROR = "unknown_error" + +@dataclass +class RepromptingConfig: + """ + Configuration for the automated re-prompting pipeline. + + Attributes: + publish (bool): Whether to publish results to app.aimon.ai. + max_iterations (int): Maximum number of re-prompting iterations (1 initial + N retries). + aimon_api_key (Optional[str]): API key for AIMon integration. Defaults to "AIMON_API_KEY" env var. + model_name (Optional[str]): Model identifier for telemetry. Defaults to "aimon-react-model-{rand}". + application_name (Optional[str]): Application identifier for telemetry. Defaults to "aimon-react-application-{rand}". + return_telemetry (bool): Whether to include per-iteration telemetry in the response. + return_aimon_summary (bool): Whether to include a human-readable caption summarizing re-prompting. (e.g.: 2 iterations, 0 failed instructions) + latency_limit_ms (Optional[int]): Maximum cumulative latency (ms) before aborting. None = no limit. + user_model_max_retries (Optional[int]): Max retries for user model calls. Defaults to 2. + feedback_model_max_retries (Optional[int]): Max retries for feedback model calls. Defaults to 2. + """ + publish: bool = False + max_iterations: int = 2 + if max_iterations < 1: + raise ValueError("Max iterations must be greater than 0") + aimon_api_key: Optional[str] = os.getenv("AIMON_API_KEY") or "default_api_key" + if aimon_api_key == "default_api_key": + raise ValueError("AIMON_API_KEY environment variable is not set and no fallback value is provided.") + model_name: Optional[str] = "aimon-react-model-" + generate_random_string(5) + application_name: Optional[str] = "aimon-react-application-" + generate_random_string(5) + return_telemetry: bool = False + return_aimon_summary: bool = False + latency_limit_ms: Optional[int] = None + user_model_max_retries: Optional[int] = 2 + feedback_model_max_retries: Optional[int] = 2 + + \ No newline at end of file diff --git a/aimon/reprompting_api/pipeline.py b/aimon/reprompting_api/pipeline.py new file mode 100644 index 0000000..61de0e8 --- /dev/null +++ b/aimon/reprompting_api/pipeline.py @@ -0,0 +1,543 @@ +from aimon.reprompting_api.config import RepromptingConfig, StopReasons +from aimon.reprompting_api.telemetry import TelemetryLogger +from aimon.reprompting_api.reprompter import Reprompter +from aimon.reprompting_api.utils import toxicity_check, get_failed_instructions_count, get_failed_instructions, get_residual_error_score +from aimon import Detect +import time +import random +from string import Template +import logging + +logger = logging.getLogger(__name__) + +class RepromptingPipeline: + """ + A pipeline for iterative re-prompting of LLM responses using AIMon evaluation. + + This pipeline orchestrates: + - Initial prompt generation for a given query, context, and user instructions. + - Interaction with a black-box LLM to generate responses. + - Evaluation of responses using AIMon detectors (instruction adherence, groundedness, toxicity). + - Iterative corrective re-prompting until stopping conditions are met. + - Collection and emission of telemetry for all iterations. + + **Expected LLM function signature**: + llm_fn(recommended_prompt_template: Template, system_prompt: str, context: str, user_query: str) -> str + + Attributes: + llm_fn (callable): Function to call the LLM. Must be a Callable with + -recommended_prompt_template: Template + -system_prompt: str + -context: str + -user_query: str + + config (RepromptingConfig): Configuration object with API keys and iteration limits. + reprompter (Reprompter): Utility for generating corrective prompts based on evaluation feedback. + telemetry (TelemetryLogger): Logger for capturing telemetry data. + detect (Detect): AIMon detection client for evaluating model responses. + + Returns: + dict: + { + "best_response" (str): Best model response across all iterations. + "telemetry" (list, optional): Iteration-level telemetry if enabled. + "summary" (str, optional): Human-readable run summary if enabled. + } + """ + def __init__(self, llm_fn, config): + """ + Initialize pipeline with LLM callable and RepromptingConfig. + + Args: + llm_fn (callable): Function to call the LLM. + Signature: llm_fn(recommended_prompt_template: Template, system_prompt: str, context: str, user_query: str) -> str + config (RepromptingConfig): Configuration object with API keys and limits. + + """ + self.llm_fn = llm_fn + self.config = config or RepromptingConfig() + + # Utilities for reprompting, telemetry, and scoring + self.reprompter = Reprompter() + self.telemetry = TelemetryLogger() + + # Initialize AIMon Detect for response evaluation + self.detect = Detect( + values_returned=['user_query', 'instructions', 'generated_text', 'context'], + config={ + "instruction_adherence": { + "detector_name": "default", + "explain": True, + "extract_from_system": False + }, + "groundedness": { + "detector_name": "default", + "explain": True + }, + "toxicity": { + "detector_name": "default", + "explain": True + } + }, + api_key=self.config.aimon_api_key, + application_name = self.config.application_name, + model_name = self.config.model_name, + publish=self.config.publish + ) + + def run(self, system_prompt: str, context: str, user_query: str, user_instructions): + """ + Execute the full re-prompting pipeline. + + Process: + 1. Build an initial prompt with query, context, and instructions. + 2. Call the LLM to generate a response. + 3. Evaluate the response with AIMon detectors. + 4. If violations are found, iteratively generate corrective prompts and re-prompt the LLM. + 5. Stop when all instructions are followed or iteration limits are reached. + 6. Return the best response (lowest residual error) along with telemetry and a summary if configured. + + Args: + user_query (str): The user's query or instruction. + context (str): Contextual information to include in the prompt. + user_instructions (list[str]): Instructions the model must follow. + + Returns: + dict: + { + "best_response" (str): Best model response from all iterations. + "telemetry" (list, optional): Telemetry for all iterations if enabled. + "summary" (str, optional): Summary of the process if enabled. + } + """ + logger.info("Starting RepromptingPipeline run") + logger.debug(f"Inputs - System Prompt: {system_prompt}, Context: {context}, User Query: {user_query}, Instructions: {user_instructions}") + iteration_outputs = {} # key: iteration number → dict(response_text, residual_error_score, failed_instructions_count) + pipeline_start = time.time() + iteration_num = 1 + + curr_prompt = self._build_original_prompt() + logger.debug(f"Initial prompt template built: {curr_prompt.template}") + + + # First LLM call + curr_generated_text = self._call_llm(curr_prompt,self.config.user_model_max_retries, system_prompt, context, user_query) + logger.debug(f"Initial LLM response: {curr_generated_text}") + + + # Evaluate response with AIMon + curr_payload = self._build_aimon_payload(context, user_query, user_instructions, curr_generated_text, system_prompt) + curr_result = self._detect_aimon_response(curr_payload, self.config.feedback_model_max_retries) + logger.debug(f"AIMon evaluation result: {curr_result}") + + # Get scores and detailed feedback on failured instructions + scores, feedback = self.get_response_feedback(curr_result) + self._record_iteration_output(iteration_outputs, iteration_num, curr_generated_text, curr_result) + + # Iteratively re-prompt until conditions are met or limits reached + stop_reason = None + while True: + should_stop, stop_reason = self._should_stop_reprompting(curr_result, iteration_num, pipeline_start) + logger.info(f"Iteration {iteration_num}: Stop decision: {should_stop}, Reason: {stop_reason}") + if should_stop: + break + + # Emit telemetry for this iteration + self._emit_iteration_telemetry( + iteration_num, + pipeline_start, + scores, + feedback, + curr_result, + stop_reason or StopReasons.CONTINUE, + curr_prompt, + curr_generated_text, + ) + + # Generate corrective prompt + curr_prompt = self._build_corrective_prompt(curr_payload, curr_result) + + # Retry LLM call with corrective prompt + curr_generated_text = self._call_llm(curr_prompt,self.config.user_model_max_retries, system_prompt, context, user_query) + # Re-evaluate the new response + curr_payload = self._build_aimon_payload(context, user_query, user_instructions, curr_generated_text, system_prompt) + curr_result = self._detect_aimon_response(curr_payload, self.config.feedback_model_max_retries) + + # Extract updated scores and feedback + scores, feedback = self.get_response_feedback(curr_result) + iteration_num += 1 + self._record_iteration_output(iteration_outputs, iteration_num, curr_generated_text, curr_result) + + # Final telemetry after loop exit + self._emit_iteration_telemetry( + iteration_num, + pipeline_start, + scores, + feedback, + curr_result, + stop_reason or StopReasons.UNKNOWN_ERROR, + curr_prompt, + curr_generated_text, + ) + + # Select best response across all iterations + best_output, best_failed_count = self._select_best_iteration(iteration_outputs) + + # Build final response payload + response = {"best_response": best_output} + if self.config.return_telemetry: + response["telemetry"] = self.telemetry.get_all() + if self.config.return_aimon_summary: + response["summary"] = self._gen_summary(iteration_num, best_failed_count) + + logger.info("RepromptingPipeline run completed") + logger.info(f"Best response selected with {best_failed_count} failed instructions remaining.") + + return response + + def _build_original_prompt(self) -> Template: + """ + Build a reusable template for combining system_prompt, context, and user_query. + This returns a string.Template object so the caller can safely substitute values. + + Placeholders: + - system_prompt + - context + - user_query + + Returns: + Template: A string.Template for building the base LLM prompt. + """ + template_str = ( + "System:\n${system_prompt}\n\n" + "Context:\n${context}\n\n" + "User Query:\n${user_query}" + ) + return Template(template_str) + + def _build_aimon_payload(self, context, user_query, user_instructions, generated_text, system_prompt): + """ + Constructs AIMon input payload. + + Args: + context (str): Context for the LLM. + user_query (str): The user's query. + user_instructions (list[str]): Instructions for the model. + generated_text (str): The model's generated response. + + Returns: + dict: Payload for AIMon evaluation. + """ + if not isinstance(user_instructions, list): + user_instructions = [] + payload = { + 'context': context, + 'user_query': user_query, + 'generated_text': generated_text, + 'instructions': user_instructions, + 'system_prompt' : system_prompt + } + return payload + + def _call_llm(self, prompt_template: Template, max_attempts, system_prompt=None, context=None, user_query=None, base_delay=1): + """ + Calls the LLM with exponential backoff. Retries if the LLM call fails + OR returns a non-string value. Raises an exception if all retries fail. + + Args: + prompt_template (Template): Prompt template for the LLM. + max_attempts (int): Max retry attempts. + base_delay (float): Initial delay in seconds before backoff. + + Returns: + str: LLM response text. + + Raises: + RuntimeError: If the LLM call fails or returns an invalid type after all retries. + """ + last_exception = None + for attempt in range(max_attempts): + try: + logger.debug(f"LLM call attempt {attempt+1} with prompt template.") + result = self.llm_fn(prompt_template, system_prompt, context, user_query) + # Validate type + if not isinstance(result, str): + raise TypeError(f"LLM returned invalid type {type(result).__name__}, expected str.") + return result + except Exception as e: + last_exception = e + logger.warning(f"LLM call failed on attempt {attempt+1}: {e}") + wait_time = base_delay * (2 ** attempt) + random.uniform(0, 0.1) + time.sleep(wait_time) + raise RuntimeError(f"LLM call failed or returned invalid type after maximum retries. Last error: {last_exception}") + + def _detect_aimon_response(self, payload, max_attempts, base_delay=1): + """ + Calls AIMon Detect with exponential backoff and returns the detection result. + + This method wraps the AIMon evaluation call, retrying if it fails due to transient + errors (e.g., network issues or temporary service unavailability). It retries up to + `max_attempts` times with exponential backoff before raising a RuntimeError. + + Args: + payload (dict): A dictionary containing 'context', 'user_query', + 'instructions', and 'generated_text' for evaluation. + max_attempts (int): Maximum number of retry attempts. + base_delay (float): Initial delay in seconds before exponential backoff. + + Returns: + object: The AIMon detection result containing evaluation scores and feedback. + + Raises: + RuntimeError: If AIMon Detect fails after all retry attempts. + """ + aimon_context = f"{payload['context']}\n\nUser Query:\n{payload['user_query']}" + aimon_query = f"{payload['user_query']}\n\nInstructions:\n{payload['instructions']}" + + @self.detect + def run_detection(query, instructions, generated_text, context): + return query, instructions, generated_text, context + + for attempt in range(max_attempts): + try: + logger.debug(f"AIMon detect attempt {attempt+1} with payload: {payload}") + _, _, _, _, result = run_detection( + aimon_query, + payload['instructions'], + payload['generated_text'], + aimon_context + ) + return result + except Exception as e: + logger.debug(f"AIMon detect failed on attempt {attempt+1}: {e}") + wait_time = base_delay * (2 ** attempt) + random.uniform(0, 0.1) + time.sleep(wait_time) + raise RuntimeError("AIMon detect call failed after maximum retries.") + + def get_response_feedback(self, result): + """ + Extract groundedness and instruction adherence scores and failed instructions. + + Args: + result (object): AIMon detection result. + + Returns: + tuple: (scores (dict), failed_instructions (list)) + """ + scores = { + "groundedness": result.detect_response.groundedness.get("score", 0.0), + "instruction_adherence": result.detect_response.instruction_adherence.get("score", 0.0) + } + feedback = get_failed_instructions(result) + return scores, feedback + + def _build_corrective_prompt(self, payload, result): + """ + Generate a corrective prompt using AIMon evaluation results. + + Args: + payload (dict): AIMon input payload. + result (object): AIMon detection result. + + Returns: + str: A corrective prompt for re-prompting the LLM. + """ + return self.reprompter.create_corrective_prompt(result, payload) + + def _should_stop_reprompting(self, result, iteration_num, pipeline_start): + """ + Determine whether to stop re-prompting. + + Stopping conditions: + - Max iterations reached. + - Latency budget 75% depleted + - All instructions are adhered to. + - Otherwise, continue if violations or toxicity remain. + + Args: + result (object): AIMon detection result. + iteration_num (int): Current iteration number. + + Returns: + tuple: + (should_stop (bool), stop_reason (str or None)) + """ + # Max iterations reached + if iteration_num >= self.config.max_iterations: + return True, StopReasons.MAX_ITERATIONS_REACHED + + latency_limit_ms = self.config.latency_limit_ms + if latency_limit_ms is not None: + cumulative_latency = self._get_cumulative_latency(pipeline_start) + if cumulative_latency > ((0.75) * latency_limit_ms): + return True, StopReasons.LATENCY_LIMIT_EXCEEDED + + # Continue if toxicity is detected + if toxicity_check(result): + return False, StopReasons.CONTINUE_TOXICITY + + # Continue if there are still failed instructions + if get_failed_instructions_count(result) > 0: + return False, StopReasons.CONTINUE + + # All instructions followed + return True, StopReasons.ALL_INSTRUCTIONS_ADHERED + + def _select_best_iteration(self, iteration_outputs): + """ + Selects the best iteration based on the lowest residual error score. + + Args: + iteration_outputs (dict): Mapping of iteration_num -> iteration data. + + Returns: + tuple: (best_output (str), best_failed_count (int)) + """ + valid_iterations = [ + entry for entry in iteration_outputs.values() + if isinstance(entry.get("residual_error_score"), (int, float)) + ] + if not valid_iterations: + return "[ERROR: No valid response]", None + + best_iteration = min(valid_iterations, key=lambda x: x["residual_error_score"]) + return best_iteration["response_text"], best_iteration["failed_instructions_count"] + + def _gen_summary(self, iteration_num, best_failed_count): + """ + Generate a human-readable summary for the pipeline run. + e.g.: "2 iterations, 0 failed instructions remaining" + + Args: + iteration_num (int): Number of iterations performed. + best_failed_count (int): Number of failed instructions in the best response. + + Returns: + str: Summary. + """ + iteration_word = "iteration" if iteration_num == 1 else "iterations" + summary = f"{iteration_num} {iteration_word}, {best_failed_count} failed instructions remaining" + return summary + + def _build_telemetry_entry( + self, + iteration, + cumulative_latency, + scores, + feedback, + residual_error, + failed_count, + stop_reason, + prompt, + response_text, + ): + """ + Build a structured telemetry entry for an iteration. + + Args: + iteration (int): Iteration number. + cumulative_latency (float): Total latency in milliseconds so far. + scores (dict): Evaluation scores. + feedback (list): Failed instruction feedback. + residual_error (float): Residual error score. + failed_count (int): Number of failed instructions. + stop_reason (str): Reason for stopping. + prompt (str): Prompt used for this iteration. + response_text (str): Model's response. + + Returns: + dict: Structured telemetry entry. + """ + return { + "iteration": iteration, + "cumulative_latency_ms": cumulative_latency, + "scores": scores, + "response_feedback": feedback, + "residual_error": residual_error, + "failed_instructions_count": failed_count, + "stop_reason": stop_reason, + "prompt": prompt, + "response_text": response_text, + } + + def _emit_iteration_telemetry( + self, + iteration_num, + pipeline_start, + scores, + feedback, + curr_result, + stop_reason, + curr_prompt, + curr_generated_text, + ): + """ + Build and emit telemetry for an iteration. Calculates cumulative latency. + + Args: + iteration_num (int): Current iteration number. + pipeline_start (float): Start time of the pipeline (epoch). + scores (dict): Evaluation scores. + feedback (list): Failed instruction feedback. + curr_result (object): AIMon detection result. + stop_reason (str): Reason for stopping or continuing. + curr_prompt (str): Prompt used. + curr_generated_text (str): Model response text. + + Returns: + dict: The telemetry entry. + """ + cumulative_latency_ms = self._get_cumulative_latency(pipeline_start) + + residual_error = get_residual_error_score(curr_result) if curr_result else None + failed_count = get_failed_instructions_count(curr_result) if curr_result else None + + prompt_text = curr_prompt.template + + entry = self._build_telemetry_entry( + iteration_num, + cumulative_latency_ms, + scores, + feedback, + residual_error, + failed_count, + stop_reason, + prompt_text, + curr_generated_text, + ) + try: + self.telemetry.emit(**entry) + except Exception as e: + logger.warning(f"[Warning] Telemetry emission failed: {e}") + return entry + + def _get_cumulative_latency(self, pipeline_start): + """ + Calculate cumulative latency since pipeline start. + + Args: + pipeline_start (float): Start time of the pipeline (epoch). + + Returns: + float: Cumulative latency in milliseconds. + """ + return (time.time() - pipeline_start) * 1000 + + def _record_iteration_output(self, iteration_outputs, iteration_num, generated_text, result): + """ + Record iteration outputs for later selection of the best response. + + Args: + iteration_outputs (dict): Stores outputs per iteration. + iteration_num (int): Current iteration number. + generated_text (str): Model's generated response. + result (object): AIMon detection result. + + Returns: + None + """ + iteration_outputs[iteration_num] = { + "response_text": generated_text, + "residual_error_score": get_residual_error_score(result), + "failed_instructions_count": get_failed_instructions_count(result) + } \ No newline at end of file diff --git a/aimon/reprompting_api/reprompter.py b/aimon/reprompting_api/reprompter.py new file mode 100644 index 0000000..e229621 --- /dev/null +++ b/aimon/reprompting_api/reprompter.py @@ -0,0 +1,218 @@ +from aimon.reprompting_api.utils import get_failed_instructions_count, get_failed_instructions, get_failed_toxicity_instructions +from string import Template +import logging + +logger = logging.getLogger(__name__) + +class Reprompter: + """ + Generates a template for corrective reprompting for improving LLM responses + based on AIMon evaluation results. This class combines failed instruction + feedback and background information to trigger iterative + improvement prompts for stateless LLMs. + The template is designed to accept substitutions for system_prompt, user_query, and context. + + Designed for use in open-source contexts where developers may want to + customize the prompt structure or language. + """ + + def create_corrective_prompt(self, result, aimon_payload: dict) -> Template: + """ + Build a corrective prompt **template** for the next LLM response. + + Placeholders: + {system_prompt} – The original system prompt + {user_query} – The user query + {context} – The context string + + Args: + result: AIMon detection result object. + aimon_payload (dict): Original payload containing: + - 'system_prompt' (str) + - 'user_query' (str) + - 'context' (str) + - 'generated_text' (str) + - 'instructions' (list[str]) + + Returns: + Template: A string.Template object (with placeholders for substitution). + """ + try: + failed_instructions = get_failed_instructions(result) + failed_count = get_failed_instructions_count(result) + logger.debug(f"Failed instructions ({failed_count}): {failed_instructions}") + + tone = self.determine_tone(failed_count) + toxicity_feedback = self.get_toxicity_reprompt(result) + failed_instructions_reprompt = self.format_failed_instructions(failed_instructions, toxicity_feedback) + passed_instructions = self.format_passed_instructions(self.get_passed_instructions(result, aimon_payload)) + generated_text = aimon_payload.get('generated_text', '') + + # Build template string (placeholders for substitution) + template_str = ( + "Original system prompt:\n" + "${system_prompt}\n\n" + "Revise your previous response to this query:\n" + "${user_query}\n\n" + "Context:\n" + "${context}\n\n" + "Previous response:\n" + f"{generated_text}\n\n" + f"{tone}\n\n" + f"{failed_instructions_reprompt}\n\n" + "Preserve correct content. Return only the revised output with no extra explanation.\n" + f"{passed_instructions}\n" + ) + logger.debug(f"Generated corrective prompt template:\n{template_str}") + return Template(template_str) + except Exception as e: + logger.error(f"Error generating corrective prompt: {e}") + raise RuntimeError( + f"Corrective prompt template generation failed: {type(e).__name__} — {e}" + ) from e + + def get_toxicity_reprompt(self, result) -> str: + """ + Generate feedback for detected toxicity failures in the following format: + Your reply contained toxic content. Remove any harmful, abusive, or unsafe language. + 1. We are X% confident that your response had the following issue: + → Violation: "..." + → Explanation: "..." + + Args: + result: AIMon detection result. + + Returns: + str: Toxicity-specific feedback, or None if no toxicity detected. + """ + try: + failed_instructions = get_failed_toxicity_instructions(result) + if not failed_instructions: + return "" + logger.info(f"Toxicity violations detected: {len(failed_instructions)}") + lines = ["Your reply contained toxic content. Remove any harmful, abusive, or unsafe language."] + for i, failed_instruction in enumerate(failed_instructions, start=1): + confidence = failed_instruction.get("score", 0.0) * 100 + confidence_str = f"{confidence:.2f}%" + lines.append( + f"{i}. We are {confidence_str} confident that your response had the following issue:\n" + f"→ Violation: \"{failed_instruction.get('instruction', '[Unknown]')}\"\n" + f"→ Explanation: {failed_instruction.get('explanation', '[No explanation provided]')}\n" + ) + return "\n\n".join(lines) + except Exception as e: + logger.error(f"Error generating toxicity feedback: {e}") + return "" + + def get_reprompt_per_instruction(self, failed_instruction): + """ + Corrective feedback for a single failed instruction in the following format: + 1. We are X% confident that the following instruction was not followed: + → Violated Instruction: "..." + → Explanation: "..." + + Args: + failed_instruction (dict): Failed instruction data containing: + - 'instruction' (str) + - 'score' (float) + - 'explanation' (str) + + Returns: + str: Formatted feedback for the failed instruction. + """ + try: + confidence = (1.0 - failed_instruction.get("score", 0.0)) * 100 + confidence_str = f"{confidence:.2f}%" + return ( + f" We are {confidence_str} confident that the following instruction was not followed:\n" + f"→ Violated Instruction: \"{failed_instruction.get('instruction', '[Unknown]')}\"\n" + f"→ Explanation: {failed_instruction.get('explanation', '[No explanation provided]')}\n" + ) + except Exception as e: + logger.error(f"Error formatting failed instruction: {e}") + raise RuntimeError( + f"Corrective prompt generation failed: Unexpected error of type {type(e).__name__} — {e}" + ) from e + + def format_failed_instructions(self, failed_instructions, toxicity_feedback: str = None): + """ + Combine toxicity feedback with general failed instructions into a formatted block. + + Args: + failed_instructions (list): List of failed instruction dictionaries. + toxicity_feedback (str, optional): Pre-generated toxicity feedback block. + + Returns: + str: Combined formatted feedback string. + """ + lines = [] + if toxicity_feedback: + lines.append(toxicity_feedback) + if failed_instructions: + lines.append("Fix the following:") + for i, error in enumerate(failed_instructions, start=1): + lines.append(f"{i}. {self.get_reprompt_per_instruction(error)}") + if not lines: + return "No major issues." + return "\n\n".join(lines) + + def get_passed_instructions(self, result, aimon_payload): + """ + Retrieve instructions that passed all adherence and groundedness checks. + + Args: + result: AIMon detection result. + aimon_payload (dict): Original payload containing the full instruction list. + + Returns: + list: Passed instruction strings. + """ + try: + all_instructions = aimon_payload.get("instructions", []) + failed_instructions = {item["instruction"] for item in get_failed_instructions(result)} + return [instr for instr in all_instructions if instr not in failed_instructions] + except Exception as e: + logger.error(f"Error determining passed instructions: {e}") + return [] + + def format_passed_instructions(self, passed_instructions) -> str: + """ + Format passed instructions to reinforce adherence in the next iteration. + + Args: + passed_instructions (list): Passed instruction strings. + + Returns: + str: Formatted reminder block for passed instructions. + """ + if not passed_instructions: + return "" + return ( + "You did well on these instructions. It is important that you continue to follow these instructions:\n" + + "\n".join(f"- {instr}" for instr in passed_instructions) + ) + + def determine_tone(self, failed_count: int) -> str: + """ + Decide the corrective prompt tone based on failure severity: + + if failed instructions >= 3: + Your reply had major issues. Fix all points below. + if failed instructions between 2 and 3: + Some parts were off. Improve using the notes below. + if less than 2: + Almost there! Just a few small fixes needed. + + Args: + failed_count (int): Total number of failed instructions. + + Returns: + str: Tone-setting string for the corrective prompt. + """ + if failed_count >= 3: + return "Your reply had major issues. Fix all points below." + elif failed_count >= 2: + return "Some parts were off. Improve using the notes below." + else: + return "Almost there. Just a few small fixes needed." + diff --git a/aimon/reprompting_api/runner.py b/aimon/reprompting_api/runner.py new file mode 100644 index 0000000..0116cca --- /dev/null +++ b/aimon/reprompting_api/runner.py @@ -0,0 +1,76 @@ +""" +runner.py — This module provides a high-level function (`run_reprompting_pipeline`) +for executing AIMon's iterative re-prompting workflow. + +This function is the primary entry point for developers and end-users. It: + - Normalizes inputs (replacing missing `system_prompt` or `context` with clear placeholders). + - Initializes the `RepromptingPipeline` with the provided configuration and LLM function. + - Runs the full re-prompting loop, generating an initial response, evaluating it, + and iteratively re-prompting until adherence criteria or stopping conditions are met. + +Contributors can extend this behavior by modifying `RepromptingPipeline` or `RepromptingConfig`. +""" +from typing import List, Optional +from aimon.reprompting_api.pipeline import RepromptingPipeline +from aimon.reprompting_api.config import RepromptingConfig + +def run_reprompting_pipeline( + llm_fn, + user_query: str, + system_prompt: str = None, + context:str = None, + user_instructions: List[str] = None, + reprompting_config: RepromptingConfig = None, +) -> dict: + """ + High-level wrapper for running the full AIMon re-prompting pipeline. + + This function prepares and normalizes all inputs, initializes the pipeline, + and executes the iterative re-prompting process. Missing `system_prompt` or + `context` values are replaced with clear placeholders (`"[no system prompt provided]"` + and `"[no context provided]"`) to ensure template consistency. + + Args: + llm_fn (Callable[[Template, str, str, str], str]): + A function to call the LLM. Must accept a prompt template (recommended_prompt_template), + `system_prompt`, `context`, and `user_query`. + user_query (str): + The user’s query. Must be a non-empty string. + system_prompt (str, optional): + A system-level instruction string. Defaults to `"[no system prompt provided]"` if None or empty. + context (str, optional): + Supplemental context for the LLM. Defaults to `"[no context provided]"` if None or empty. + user_instructions (List[str], optional): + A list of instructions for the model to follow. Defaults to an empty list. + reprompting_config (RepromptingConfig, optional): + Configuration object for controlling pipeline behavior. + + Returns: + dict: A structured dictionary containing: + - "best_response" (str): The final, best LLM response. + - "telemetry" (list, optional): Iteration-level telemetry if enabled in config. + - "summary" (str, optional): A human-readable summary of the process if enabled. + """ + + # Use the provided config or fall back to defaults + config = reprompting_config or RepromptingConfig() + + # validate llm_fn + if not callable(llm_fn): + raise TypeError("llm_fn must be a callable that returns a string.") + + if not user_query or not isinstance(user_query, str): + raise ValueError("user_query must be a non-empty string.") + + context = context if (context and isinstance(context, str)) else "[no context provided]" + system_prompt = system_prompt if (system_prompt and isinstance(system_prompt, str)) else "[no system prompt provided]" + + # initialize the re-prompting pipeline with the LLM function and configuration + pipeline = RepromptingPipeline(llm_fn=llm_fn, config=config) + + return pipeline.run( + system_prompt=system_prompt, + context=context, + user_query=user_query, + user_instructions=user_instructions or [] # Default to empty list if none provided + ) \ No newline at end of file diff --git a/aimon/reprompting_api/telemetry.py b/aimon/reprompting_api/telemetry.py new file mode 100644 index 0000000..a301308 --- /dev/null +++ b/aimon/reprompting_api/telemetry.py @@ -0,0 +1,75 @@ +import json +import uuid +from datetime import datetime + +class TelemetryLogger: + """ + A lightweight logger for recording telemetry events during re-prompting pipeline execution. + + Telemetry is stored in memory for retrieval and returned by the pipeline when requested. + """ + def __init__(self): + """Initialize an in-memory telemetry logger.""" + self.session_id = str(uuid.uuid4()) + self.memory_store = [] + + def emit( + self, + iteration: int, + cumulative_latency_ms: float, + scores: dict, + response_feedback: dict, + residual_error: float, + failed_instructions_count: int, + stop_reason: str, + response_text: str, + prompt: str = "", + ): + """ + Emit a single telemetry entry. + + Args: + iteration (int): The iteration number of the pipeline (starts at 1). + cumulative_latency_ms (float): Total latency from pipeline start (ms). + scores (dict): Evaluation scores (e.g., groundedness, instruction adherence). + response_feedback (dict): Feedback for failed instructions. + residual_error (int): Residual error score. + failed_instructions_count (int): Count of instructions not followed. + stop_reason (str): Reason for stopping or continuing. + response_text (str): The raw text response from the LLM. + prompt (str): The prompt text used for this iteration. + """ + telemetry = { + # not returned + "_timestamp": datetime.utcnow().isoformat() + "Z", + "_session_id": self.session_id, + # returned + "iteration": iteration, + "cumulative_latency_ms": cumulative_latency_ms, + "scores": scores, + "response_feedback": response_feedback, + "residual_error": residual_error, + "failed_instructions_count": failed_instructions_count, + "stop_reason": stop_reason, + "promp_template": prompt, + "response_text": response_text, + } + self.memory_store.append(telemetry) + + def get_all(self, include_meta=False): + """ + Return all recorded telemetry entries. + + Args: + include_meta (bool): If True, includes session_id and timestamp. Defaults to False. + + Returns: + list: Telemetry entries, stripped of internal metadata unless requested. + """ + if include_meta: + return self.memory_store + # Strip out keys starting with "_" for external return + sanitized = [] + for entry in self.memory_store: + sanitized.append({k: v for k, v in entry.items() if not k.startswith("_")}) + return sanitized diff --git a/aimon/reprompting_api/tests/_init_.py b/aimon/reprompting_api/tests/_init_.py new file mode 100644 index 0000000..e69de29 diff --git a/aimon/reprompting_api/tests/test_reprompting_cases.py b/aimon/reprompting_api/tests/test_reprompting_cases.py new file mode 100644 index 0000000..46d3079 --- /dev/null +++ b/aimon/reprompting_api/tests/test_reprompting_cases.py @@ -0,0 +1,172 @@ +import os +import pytest +from string import Template +from together import Together +from aimon.reprompting_api.config import RepromptingConfig +from aimon.reprompting_api.runner import run_reprompting_pipeline + +TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") +AIMON_API_KEY = os.environ.get("AIMON_API_KEY") + +client = Together(api_key=TOGETHER_API_KEY) + +# --- Fixtures --- + +@pytest.fixture +def my_llm(): + def _my_llm(recommended_prompt_template: Template, system_prompt, context, user_query) -> str: + filled_prompt = recommended_prompt_template.substitute( + system_prompt=system_prompt or "", + context=context or "", + user_query=user_query or "" + ) + print("====prompt===") + print(filled_prompt) + response = client.chat.completions.create( + model="mistralai/Mistral-7B-Instruct-v0.2", + messages=[{"role": "user", "content": filled_prompt}], + max_tokens=256, + temperature=0 + ) + return response.choices[0].message.content + return _my_llm + +@pytest.fixture +def base_config(): + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=2, + ) + +@pytest.fixture +def config_without_telemetry(): + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=False, + return_aimon_summary=False, + application_name="api_test", + max_iterations=2, + ) + +@pytest.fixture +def config_low_latency(): + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=2, + latency_limit_ms=100 + ) + +@pytest.fixture +def config_high_latency(): + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=3, + latency_limit_ms=5000 + ) + +@pytest.fixture +def config_iteration_limit(): + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=-1, + ) + +# --- Tests --- + +@pytest.mark.integration +def test_low_latency_limit(my_llm, config_low_latency): + result = run_reprompting_pipeline( + user_query="Test latency limit termination return", + context="Context", + llm_fn=my_llm, + reprompting_config=config_low_latency, + user_instructions=[] + ) + assert "best_response" in result + +@pytest.mark.integration +def test_latency_limit(my_llm, config_high_latency): + result = run_reprompting_pipeline( + user_query="What is context?", + context="Context", + llm_fn=my_llm, + reprompting_config=config_high_latency, + user_instructions=["Do not use the letter e", "Only use the letter e"] + ) + assert "best_response" in result + +@pytest.mark.integration +def test_iteration_limit(my_llm, config_iteration_limit): + result = run_reprompting_pipeline( + user_query="What's the policy?", + context="hi", + llm_fn=my_llm, + reprompting_config=config_iteration_limit, + user_instructions=[] + ) + assert "best_response" in result + +@pytest.mark.integration +def test_empty_context_and_instructions(my_llm, base_config): + result = run_reprompting_pipeline( + user_query="What's the policy?", + context="", + llm_fn=my_llm, + reprompting_config=base_config, + user_instructions=[] + ) + assert "best_response" in result + +@pytest.mark.integration +def test_no_telemetry(my_llm, config_without_telemetry): + result = run_reprompting_pipeline( + user_query="What's the policy?", + context="Context for telemetry disabled run", + llm_fn=my_llm, + reprompting_config=config_without_telemetry, + user_instructions=[] + ) + assert "telemetry" not in result + assert "summary" not in result + +@pytest.mark.integration +def test_no_system_prompt(my_llm, base_config): + result = run_reprompting_pipeline( + user_query="What's the policy?", + context="Context for telemetry disabled run", + llm_fn=my_llm, + reprompting_config=base_config, + user_instructions=["use the letter e only", "do not use the letter e"] + ) + assert "best_response" in result + +@pytest.mark.integration +def test_with_system_prompt(my_llm, base_config): + result = run_reprompting_pipeline( + user_query="What's the policy?", + context="Context for telemetry disabled run", + llm_fn=my_llm, + reprompting_config=base_config, + user_instructions=["use the letter e only", "do not use the letter e", "use a neutral tone"], + system_prompt="this is a system prompt" + ) + assert "best_response" in result + assert "telemetry" in result + assert "summary" in result diff --git a/aimon/reprompting_api/tests/test_reprompting_failures.py b/aimon/reprompting_api/tests/test_reprompting_failures.py new file mode 100644 index 0000000..aacc764 --- /dev/null +++ b/aimon/reprompting_api/tests/test_reprompting_failures.py @@ -0,0 +1,123 @@ +import os +import pytest +from string import Template +from together import Together +from aimon.reprompting_api.config import RepromptingConfig +from aimon.reprompting_api.runner import run_reprompting_pipeline + +TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") +AIMON_API_KEY = os.environ.get("AIMON_API_KEY") +client = Together(api_key=TOGETHER_API_KEY) + +# --- MOCKED LLM FUNCTIONS --- +def my_llm(prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: + """Simulates a normal working LLM that returns a string response.""" + filled_prompt = prompt_template.substitute( + system_prompt=system_prompt or "", + context=context or "", + user_query=user_query or "" + ) + response = client.chat.completions.create( + model="mistralai/Mistral-7B-Instruct-v0.2", + messages=[{"role": "user", "content": filled_prompt}], + max_tokens=256, + temperature=0 + ) + return response.choices[0].message.content + +def llm_fn_failure(prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: + """Simulates an LLM call that fails every time.""" + raise RuntimeError("LLM call failed intentionally for testing") + +def llm_fn_incorrect_return_value(prompt_template: Template, system_prompt=None, context=None, user_query=None): + """Simulates an LLM that returns an invalid type instead of a string.""" + return 42 + +# --- MOCKED CONFIG FACTORIES --- +def get_config(): + """Returns a valid base configuration for most tests.""" + return RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=2, + ) + +def get_config_with_invalid_aimon_api_key(): + """Returns a config with an intentionally invalid AIMon API key.""" + return RepromptingConfig( + aimon_api_key="invalid key", + publish=False, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=3, + ) + +# --- TESTS EXPECTING FAILURES --- +@pytest.mark.integration +def test_llm_failure(): + """Should raise RuntimeError when the LLM function always fails.""" + config = get_config() + with pytest.raises(RuntimeError, match="LLM call failed or returned invalid type after maximum retries."): + run_reprompting_pipeline( + user_query="Test LLM failure handling", + context="Context for failure test", + llm_fn=llm_fn_failure, + reprompting_config=config, + user_instructions=[] + ) + +@pytest.mark.integration +def test_invalid_llm_fn(): + """Should raise TypeError when LLM function is None.""" + config = get_config() + with pytest.raises(TypeError): + run_reprompting_pipeline( + user_query="Test invalid LLM fn", + context="Context for failure test", + llm_fn=None, + reprompting_config=config, + user_instructions=[] + ) + +@pytest.mark.integration +def test_invalid_return_value(): + """Should raise RuntimeError when the LLM returns a non-string value.""" + config = get_config() + with pytest.raises(RuntimeError, match="LLM call failed or returned invalid type"): + run_reprompting_pipeline( + user_query="Test invalid return type", + context="Context for type error", + llm_fn=llm_fn_incorrect_return_value, + reprompting_config=config, + user_instructions=[] + ) + +@pytest.mark.integration +def test_empty_query(): + """Empty query should raise a ValueError.""" + config = get_config() + with pytest.raises(ValueError, match="user_query must be a non-empty string"): + run_reprompting_pipeline( + user_query="", + context="", + llm_fn=my_llm, + reprompting_config=config, + user_instructions=[] + ) + +@pytest.mark.integration +def test_invalid_api_key(): + """Should fail due to invalid AIMon API key.""" + config = get_config_with_invalid_aimon_api_key() + with pytest.raises(RuntimeError): + run_reprompting_pipeline( + user_query="Testing with invalid AIMon API key", + context="Context for invalid key test", + llm_fn=my_llm, + reprompting_config=config, + user_instructions=[] + ) diff --git a/aimon/reprompting_api/tests/test_reprompting_success.py b/aimon/reprompting_api/tests/test_reprompting_success.py new file mode 100644 index 0000000..10cc66f --- /dev/null +++ b/aimon/reprompting_api/tests/test_reprompting_success.py @@ -0,0 +1,106 @@ +import os +import logging +from string import Template +from together import Together +from aimon.reprompting_api.config import RepromptingConfig +from aimon.reprompting_api.runner import run_reprompting_pipeline + +# --- Configure logging --- +logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") +logger = logging.getLogger(__name__) + +# --- Load API keys --- +TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") +AIMON_API_KEY = os.environ.get("AIMON_API_KEY") +if not TOGETHER_API_KEY or not AIMON_API_KEY: + logger.warning("API keys are missing. Make sure TOGETHER_API_KEY and AIMON_API_KEY are set.") + +# --- Initialize Together client --- +client = Together(api_key=TOGETHER_API_KEY) + +# --- LLM Function --- +def my_llm(recommended_prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: + """ + Example LLM function that: + 1. Receives a corrective prompt template (string.Template). + 2. Substitutes placeholders (system_prompt, context, user_query). + 3. Sends to a Together-hosted LLM and returns the response. + """ + filled_prompt = recommended_prompt_template.substitute( + system_prompt=system_prompt or "", + context=context or "", + user_query=user_query or "" + ) + logger.info(f"[LLM] Sending prompt to model: {filled_prompt[:200]}...") # Log preview + + response = client.chat.completions.create( + model="mistralai/Mistral-7B-Instruct-v0.2", + messages=[{"role": "user", "content": filled_prompt}], + max_tokens=256, + temperature=0 + ) + output = response.choices[0].message.content + logger.info(f"[LLM] Received response: {output[:200]}...") + return output + +# --- Test Case: Successful Run --- +def test_successful_run(): + """ + Simulates a realistic pipeline run with: + - Complex context + - Query for simplification + - Multiple style/tone instructions + - Telemetry & summary enabled + """ + logger.info("[Pipeline] Starting test run...") + + config = RepromptingConfig( + aimon_api_key=AIMON_API_KEY, + publish=True, + return_telemetry=True, + return_aimon_summary=True, + application_name="api_test", + max_iterations=3 + ) + logger.info("[Pipeline] Config prepared.") + + user_query = "what are the drug tiers?" + context = "[SECTION] 📘 BlueShield Rx Policy Addendum: 2023–2025 ... (truncated for brevity)" + user_instructions = [ + "Avoid overly technical or robotic phrasing; keep the tone human and accessible.", + "Ensure the response is direct and professional, with minimal informal tone.", + "Translate or simplify technical details from the context into accurate, user-friendly explanations.", + "Don't use the letter e", + "only use the letter e" + ] + logger.info(f"[Pipeline] User query: {user_query}") + logger.info(f"[Pipeline] Context: {context[:100]}...") + logger.info(f"[Pipeline] Instructions: {user_instructions}") + + # Run pipeline + result = run_reprompting_pipeline( + llm_fn=my_llm, + user_query=user_query, + system_prompt="here is a system prompt", + context=context, + user_instructions=user_instructions, + reprompting_config=config + ) + + # Log each part of the result + logger.info("[Pipeline] Run complete.") + logger.info(f"[Pipeline] Best Response: {result['best_response']}") + logger.info(f"[Pipeline] Telemetry: {result.get('telemetry')}") + logger.info(f"[Pipeline] Summary: {result.get('summary')}") + + # Print outputs for inspection + print("\n=== BEST RESPONSE ===") + print(result["best_response"]) + print("\n=== TELEMETRY ===") + print(result.get("telemetry")) + print("\n=== SUMMARY ===") + print(result.get("summary")) + +# --- Entry Point --- +if __name__ == "__main__": + test_successful_run() diff --git a/aimon/reprompting_api/utils.py b/aimon/reprompting_api/utils.py new file mode 100644 index 0000000..380ef87 --- /dev/null +++ b/aimon/reprompting_api/utils.py @@ -0,0 +1,185 @@ +""" +utils.py — Utility functions for processing AIMon reprompting detector results. + +This module provides helper functions for: +- Extracting failed instructions across instruction adherence, groundedness, and toxicity detectors. +- Calculating a residual error score (0–1) for evaluating LLM responses. + +These utilities are primarily used by the RepromptingPipeline to: +- Build telemetry. +- Select best iterations. +- Guide corrective re-prompting logic. + +Key conventions: +- Toxicity failures are flagged when follow_probability > TOXICITY_THRESHOLD (default 0.25). +- Residual error scoring penalizes low follow probabilities more heavily and adds a flat penalty for any toxicity failures. +""" +from typing import List + +# toxicity threshold for AIMon detection; Follow probabilities above this are considered failures +TOXICITY_THRESHOLD = 0.25 + +def _count_toxicity_failures(result) -> int: + """ + Count the number of toxicity instructions whose follow probability exceeds the threshold. + + Args: + result: AIMon detection result containing a `toxicity` section. + + Returns: + int: Number of failed toxicity instructions. + """ + return sum( + 1 + for inst in result.detect_response.toxicity.get("instructions_list", []) + if inst.get("follow_probability", 0.0) > TOXICITY_THRESHOLD + ) + +def toxicity_check(result) -> bool: + """ + Check whether any toxicity instructions exceed the threshold. + + Args: + result: AIMon detection result containing a `toxicity` section. + + Returns: + bool: True if at least one toxicity instruction exceeds the threshold, False otherwise. + """ + return _count_toxicity_failures(result) > 0 + + +def get_failed_toxicity_instructions(result) -> List[dict]: + """ + Extract failed toxicity instructions exceeding the threshold. + + Args: + result: AIMon detection result containing a `toxicity` section. + + Returns: + List[dict]: A list of dictionaries, each describing a failed toxicity instruction with: + - type (str): "toxicity_failure" + - source (str): "toxicity" + - instruction (str): The instruction text. + - score (float): The follow probability. + - explanation (str): The explanation for the failure. + """ + failed = [] + for inst in result.detect_response.toxicity.get("instructions_list", []): + if inst.get("follow_probability", 0.0) > TOXICITY_THRESHOLD: + failed.append({ + "type": "toxicity_failure", + "source": "toxicity", + "instruction": inst.get("instruction", ""), + "score": inst.get("follow_probability", 0.0), + "explanation": inst.get("explanation", "") + }) + return failed + +def get_failed_instructions(result) -> List[dict]: + """ + Extract all failed instructions from adherence, groundedness, and toxicity detectors. + + Args: + result: AIMon detection result containing `instruction_adherence`, `groundedness`, and `toxicity` sections. + + Returns: + List[dict]: A list of failed instructions with: + - type (str): Failure type ("instruction_adherence_failure", "groundedness_failure", "toxicity_failure"). + - source (str): Detector source ("instruction_adherence", "groundedness", "toxicity"). + - instruction (str): The instruction text. + - score (float): Follow probability. + - explanation (str): Explanation for the failure. + """ + failed = [] + # Adherence & groundedness + for source in ["instruction_adherence", "groundedness"]: + for inst in getattr(result.detect_response, source, {}).get("instructions_list", []): + if not inst.get("label", True): + failed.append({ + "type": f"{source}_failure", + "source": source, + "instruction": inst.get("instruction", ""), + "score": inst.get("follow_probability", 0.0), + "explanation": inst.get("explanation", "") + }) + # Sort by score (most confident first) + failed.sort(key=lambda x: x["score"], reverse=True) + return failed + +def get_failed_instructions_count(result) -> int: + """ + Count all failed instructions across adherence, groundedness, and toxicity. + + Args: + result: AIMon detection result containing `instruction_adherence`, `groundedness`, and `toxicity` sections. + + Returns: + int: Total number of failed instructions. + """ + count = 0 + # Instruction adherence + for inst in result.detect_response.instruction_adherence.get("instructions_list", []): + if not inst.get("label", True): + count += 1 + # Groundedness + for inst in result.detect_response.groundedness.get("instructions_list", []): + if not inst.get("label", True): + count += 1 + count += _count_toxicity_failures(result) # Toxicity + return count + +def get_residual_error_score(result): + """ + Compute a normalized residual error score (0–1) based on: + - Groundedness follow probabilities + - Instruction adherence follow probabilities + - Toxicity failures (adds a strong penalty) + + Logic: + 1. Compute a base penalty using groundedness & adherence: + - Each instruction's penalty = (1 - p), doubled if p < 0.5. + - Average across all instructions for a base score. + 2. Add a flat toxicity penalty (+0.3) if any toxicity failures exist. + 3. Clamp the final score to [0,1]. + + Args: + result: AIMon detection result with `instruction_adherence`, `groundedness`, and `toxicity` sections. + + Returns: + float: Residual error score (0 = perfect, 1 = worst). The float is rounded to two decimal places. + """ + combined_probs = [ + item["follow_probability"] + for source in ["groundedness", "instruction_adherence"] + for item in getattr(result.detect_response, source, {}).get("instructions_list", []) + ] + base_penalty = penalized_average(combined_probs) if combined_probs else 0.0 + + toxicity_penalty = 0.3 if _count_toxicity_failures(result) > 0 else 0.0 + + residual_error_score = base_penalty + toxicity_penalty + residual_error_score = min(1.0, max(0.0, residual_error_score)) + + return round(residual_error_score, 2) + + +def penalized_average(probs: List[float]) -> float: + """ + Compute a penalized average of follow probabilities. + + Penalizes probabilities <0.5 more heavily by doubling their penalty. + + Args: + probs (List[float]): A list of follow probabilities. + + Returns: + float: Penalized average. + """ + penalties = [] + for p in probs: + if p >= 0.5: + penalty = 1 - p + else: + penalty = (1 - p) * 2 # heavier penalty + penalties.append(penalty) + return sum(penalties) / len(penalties) \ No newline at end of file From 904320ed281ac1f9fdef19fdf786b5b15d29be4d Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Tue, 29 Jul 2025 17:43:32 -0700 Subject: [PATCH 02/10] updating tests_reprompting_cases.py to contain different queries and contexts --- .../tests/test_reprompting_cases.py | 65 ++++++++++++++----- 1 file changed, 47 insertions(+), 18 deletions(-) diff --git a/aimon/reprompting_api/tests/test_reprompting_cases.py b/aimon/reprompting_api/tests/test_reprompting_cases.py index 46d3079..89587b6 100644 --- a/aimon/reprompting_api/tests/test_reprompting_cases.py +++ b/aimon/reprompting_api/tests/test_reprompting_cases.py @@ -14,20 +14,23 @@ @pytest.fixture def my_llm(): + """Mock LLM function for integration tests. Prints prompts and responses.""" def _my_llm(recommended_prompt_template: Template, system_prompt, context, user_query) -> str: filled_prompt = recommended_prompt_template.substitute( system_prompt=system_prompt or "", context=context or "", user_query=user_query or "" ) - print("====prompt===") - print(filled_prompt) + print("\n==== LLM PROMPT SENT ====", flush=True) + print(filled_prompt, flush=True) response = client.chat.completions.create( model="mistralai/Mistral-7B-Instruct-v0.2", messages=[{"role": "user", "content": filled_prompt}], max_tokens=256, temperature=0 ) + print("\n==== LLM RAW RESPONSE ====", flush=True) + print(response.choices[0].message.content, flush=True) return response.choices[0].message.content return _my_llm @@ -88,85 +91,111 @@ def config_iteration_limit(): max_iterations=-1, ) +# --- Helper to print results nicely --- +def print_result(test_name, result): + print(f"\n===== RESULTS FOR: {test_name} =====", flush=True) + print("\n==== BEST RESPONSE ====", flush=True) + print(result.get("best_response"), flush=True) + print("\n==== TELEMETRY ====", flush=True) + print(result.get("telemetry"), flush=True) + print("\n==== SUMMARY ====", flush=True) + print(result.get("summary"), flush=True) + print("===== END OF RESULT =====\n", flush=True) + # --- Tests --- @pytest.mark.integration def test_low_latency_limit(my_llm, config_low_latency): + """Test stopping behavior when latency limit is very low (100ms).""" result = run_reprompting_pipeline( - user_query="Test latency limit termination return", - context="Context", + user_query="We just received a Cal/OSHA citation for emergency workplace safety violations with a 15-day correction deadline. What are our options to appeal or resolve this without facing business closure?", + context="(Form DOSH-TRN-2025) [SECTION] Section 4: Consequences of Non-Compliance [SECTION] Failing to act may result in: [SECTION] - Daily penalties of $500 per violation after deadline [SECTION] - Business closure orders for willful violations [SECTION] - 300% penalty enhancements for repeat offenses [SECTION] Section 5: Recommended Resolution Path [SECTION] For fastest resolution: [SECTION] 1. Correct all hazards within 10 days [SECTION] 2. Submit Form DOSH-RESP-2025 with evidence [SECTION] 3. Request compliance verification inspection [SECTION] Remember: Appeal filings don’t suspend correction deadlines—address hazards immediately while preserving your appeal rights.[SECTION] California Business Emergency Preparedness Compliance Guide – 2025 Edition [SECTION] Document Ref: CA-BEP-2025-09 / Effective July 1, 2025 [SECTION] Section 1: Mandatory Earthquake Preparedness Protocol [SECTION] All California businesses with 10+ employees must maintain an approved earthquake readiness plan under CA Labor Code §6401.7. Don't worry—we'll walk you through each requirement step by step. [SECTION] 1. Plan Submission: [SECTION] - Complete Form BEP-22 (Earthquake Preparedness Certification) [SECTION] - Submit via CalOES Business Portal or mail to: [SECTION] Office of Emergency Services [SECTION] Business Compliance Division [SECTION] P.O. Box 419047 [SECTION] Sacramento, CA 95841 [SECTION] - Deadline: Within 30 days of plan creation or update [SECTION] 2. Employee Training: [SECTION] - Conduct quarterly drills using state-approved materials (Reference Guide BEP-TM-2025) [SECTION] - Maintain signed attendance records (Form BEP-23) for 3 years [SECTION] - New hires must complete training within 14 days of employment [SECTION] 3. Emergency Supplies: [SECTION] - Minimum 3-day water supply (1 gallon per person per day) [SECTION] - First aid kits meeting ANSI/ISEA Z308.1-2025 standards [SECTION] - Emergency lighting for all exits (tested monthly) [SECTION] - Battery-powered NOAA weather radio [SECTION] Section 2: Compliance Verification Process [SECTION] To schedule verification: [SECTION] 1. Create account on CalOES Business Portal (portal.caloes.ca.gov) [SECTION] 2. Submit Inspection Request Form BEP-30 [SECTION] 3. Pay verification fee: [SECTION] - $150 standard fee [SECTION] - $75 for businesses with 10-24 employees [SECTION] - Waived for non-profits with Form BEP-31 [SECTION] 4. Prepare for inspection: [SECTION] - Printed copy of Form BEP-22 submission receipt [SECTION] - Training records (Forms BEP-23 and BEP-23A) [SECTION] - Current supply inventory log (Form BEP-24) [SECTION] Section 3: Non-Compliance Penalties [SECTION] - First violation: $500 fine + mandatory corrective action plan (Form BEP-40) [SECTION] - Subsequent violations: $1,000 per occurrence [SECTION] - Willful neglect: Up to $5,000 + business license suspension [SECTION] - False certification: Misdemeanor charge under CA Business Code §17200 [SECTION] Section 6: Penalties for Non-Compliance [SECTION] Failure to properly report may result in: [SECTION] - Fines up to $25,000 per violation under Labor Code §6429. [SECTION] - Business license suspension for repeat offenses. [SECTION] - Potential criminal charges for willful violations causing harm. [SECTION] Section 7: Additional Resources [SECTION] - Cal/OSHA Spill Response Guidelines: dir.ca.gov/dosh/chemical-spills.html [SECTION] - 24/7 Emergency Consultation: 1-800-963-9424 [SECTION] - Small Business Compliance Assistance: 1-800-400-7115[SECTION] California Business Energy Efficiency Installation Guide – 2025 Edition [SECTION] ## Section 1: Understanding Your CBESP Installation Requirements [SECTION] You're asking about installing energy efficiency equipment under the CBESP program—let's walk through this step by step. The process is straightforward when you follow these guidelines. We recommend starting with a certified site assessment to maximize your benefits. [SECTION] ## Section 2: Pre-Installation Checklist [SECTION] Before installation begins: [SECTION] 1. Verify Equipment Eligibility: Check the CBESP-approved equipment list (available at cbesp.ca.gov/equipment) for your business category. For example, commercial kitchens must use NSF-certified refrigeration units. [SECTION] 2. Schedule Site Assessment: Contact a CBESP-certified assessor within 5 business days—this helps identify the best equipment placement and potential rebates. [SECTION] 3. Submit Installation Plan: Complete Form CBESP-IP-2025 with details like equipment specifications and safety protocols. [SECTION] ## Section 3: Installation Protocol [SECTION] Follow these key steps: [SECTION] 1. Power Isolation: Shut off circuits following standard safety procedures (typically 1-2 hours for most facilities). [SECTION] 2. Equipment Mounting: Use manufacturer-specified brackets with proper bracing in seismic zones. [SECTION] 3. Wiring Compliance: Follow all electrical safety requirements—consult an electrician if unsure. [SECTION] ## Section 4: Post-Installation Process [SECTION] 1. Functional Testing: Run diagnostic cycles for 24-48 hours to confirm everything works properly. [SECTION] 2. Documentation: Submit Form ICF-2025 within 3 business days of completion. [SECTION] 3. Inspector Scheduling: Request CBESP verification within 14 calendar days to avoid reinspection fees. [SECTION] ## Section 5: Important Deadlines [SECTION] - Assessment scheduling: Within 5 business days of equipment purchase [SECTION] - Form submission: 3 business days post-installation [SECTION] - Verification request: Within 14 calendar days of completion [SECTION] ## Section 6: Non-Compliance Consequences [SECTION] Not following procedures may result in:SECTION] 3. Referral to the California Franchise Tax Board for collection [SECTION] Section 5: Urgent Support Resources [SECTION] For time-sensitive applications: [SECTION] 1. Call the Disaster Relief Hotline: 1-800-CA-BIZ-AID (option 2 for expedited processing) [SECTION] 2. Email emergency@ca-bfa.gov with subject line URGENT: [Your Business Name] [SECTION] 3. Visit designated disaster recovery centers (list at ca-bfa.gov/locations) [SECTION] Note: Applications submitted after the 14-day window will be processed under standard timelines (4–6 weeks).[SECTION] California Business Licensing Compliance Guide – 2025 Edition [SECTION] Document Ref: CA-BLC-2025-12 / Effective July 1, 2025 [SECTION] Section 1: Renewal Notice Verification [SECTION] 1. Submit Form BLC-ADDR-2025 through our online portal or by mail to verify your address on file. Processing takes 3 business days. [SECTION] 2. If your address is correct but the notice hasn't arrived, request a duplicate notice by calling 1-800-CA-BIZLIC or visiting any Regional Business License Center. [SECTION] 3. For urgent renewals, submit Form BLC-RENEW-2025 with a written explanation of the missing notice. [SECTION] Section 2: Required Renewal Documentation [SECTION] To complete your renewal, you must provide: [SECTION] 1. Form BLC-RENEW-2025 with Sections A, C, and E completed [SECTION] 2. Your current business license number from prior correspondence [SECTION] 3. Proof of local zoning compliance (Form ZON-2025 or equivalent) [SECTION] Section 3: Late Renewal Procedures [SECTION] Renewals submitted within 30 days of expiration require: [SECTION] 1. Payment of $50 late fee via Form BLC-LATE-2025 [SECTION] 2. Submission of all standard renewal documents [SECTION] 3. Written justification for delay [SECTION] After 30 days, you must submit Form BLC-NEW-2025 for full reapplication. [SECTION] Section 4: Operating Without Renewal [SECTION] Continuing business operations with an expired license may result in: [SECTION] 1. Fines of $500 per violation [SECTION] 2. Mandatory compliance review (Form BLC-COMP-2025) [SECTION] 3. Potential license suspension for repeated violations", llm_fn=my_llm, reprompting_config=config_low_latency, - user_instructions=[] + user_instructions=["Use sentence structures that sound natural in spoken English, avoiding overly formal or stilted constructions.","Do not suggest actions that bypass or undermine official company processes (e.g., “You could just submit a new request under a different name”); mentioning formal appeal or exception procedures is acceptable if supported by context."] ) + print_result("Low Latency Limit Test (100ms)", result) assert "best_response" in result @pytest.mark.integration def test_latency_limit(my_llm, config_high_latency): + """Test behavior with a high latency limit and contradictory instructions.""" result = run_reprompting_pipeline( - user_query="What is context?", - context="Context", + user_query="I manage data compliance for a healthcare startup using CloudSync's Enterprise tier. We need to ensure all patient-related files are automatically deleted after 7 years to meet HIPAA requirements, while maintaining the ability to recover accidentally deleted files for at least 30 days. Can CloudSync support this workflow, and what configuration changes would we need to make?", + context="[SECTION] # Data Retention and Privacy Policy for CloudSync Services [SECTION] ## Overview [SECTION] This document outlines the data retention, storage, and privacy practices for CloudSync, a cloud-based file synchronization service. It applies to all users of the Free, Pro, and Enterprise tiers unless superseded by a signed Enterprise Agreement. [SECTION] ## Data Retention Periods [SECTION] - **Active Accounts:** User data is retained indefinitely unless manually deleted by the user or via automated compliance workflows (e.g., legal hold expiration). [SECTION] - **Inactive Accounts:** Accounts with no login activity for 24 months are flagged for review. After 30 days in review status, data is permanently deleted unless an extension is requested via Form CS-102. [SECTION] - **Deleted Files:** Files removed from the trash bin are retained in a recoverable state for 30 days. After this period, they are irreversibly purged from all systems. [SECTION] ## Privacy Controls [SECTION] Users can configure: [SECTION] - Automatic deletion of files older than a specified age (1, 3, or 5 years) [SECTION] - Geographic restrictions for data storage (US, EU, or APAC regions) [SECTION] - Access logs retention (default 90 days, extendable to 365 days for Enterprise) [SECTION] ## Legal and Compliance [SECTION] - Data may be retained beyond standard periods if subject to litigation hold, subpoena, or regulatory investigation. Users will be notified unless prohibited by law. [SECTION] - Third-party audits are conducted annually for SOC 2 Type II compliance. Reports available upon request for Enterprise customers. [SECTION] - Data sovereignty requirements are enforced at the storage layer; metadata may transit through global networks for synchronization purposes. [SECTION] ## Data Recovery [SECTION] - Enterprise accounts can request point-in-time recovery for entire accounts (14-day window) or individual files (30-day window). [SECTION] - Recovery operations incur a $150 base fee plus $0.03/GB for data restored. [SECTION] ## Policy Changes [SECTION] - Notice of material changes will be provided 60 days in advance via email and in-app notifications. [SECTION] - Continued use of the service after changes take effect constitutes acceptance of the new terms.", llm_fn=my_llm, reprompting_config=config_high_latency, user_instructions=["Do not use the letter e", "Only use the letter e"] ) + print_result("High Latency Limit Test (5000ms)", result) assert "best_response" in result @pytest.mark.integration def test_iteration_limit(my_llm, config_iteration_limit): + """Test behavior when max_iterations is unlimited (-1).""" result = run_reprompting_pipeline( - user_query="What's the policy?", - context="hi", + user_query="Our systems are showing vulnerability alerts but we can't find the patch file in the vendor portal. What should we do?", + system_prompt="Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)", + context="[SECTION] # Emergency Software Patch Installation Guide [SECTION] ## Critical Security Patch Notification – CVE-2025-1234 [SECTION] This notice applies to all systems running versions prior to 3.2.1. Immediate action is required under Cybersecurity Policy CP-2025-07 to address authentication vulnerabilities. [SECTION] ## Patch Acquisition Procedures [SECTION] 1. Verify your system meets the requirements using Form LIC-VER-15 [SECTION] 2. Access the Emergency Patch Portal at epp.vendor.com/alert/CVE-2025-1234 [SECTION] 3. If the patch isn't available, submit Form PATCH-REQ-22 for manual distribution [SECTION] ## Installation Process [SECTION] We understand urgent updates can be stressful—here's how to proceed safely: [SECTION] 1. First, create a complete system backup [SECTION] 2. Run the patch installer with administrator privileges [SECTION] 3. Check the system logs to confirm successful installation [SECTION] ## Post-Installation Steps [SECTION] - Submit Form EP-ACK-22 within 24 hours [SECTION] - Retain installation records for 90 days [SECTION] - Schedule a security scan within 7 days [SECTION] ## Support Options [SECTION] - 24/7 Technical Support: 1-800-PATCH-HELP [SECTION] - Priority assistance: Submit Form IRF-89 with CRITICAL flag", llm_fn=my_llm, reprompting_config=config_iteration_limit, - user_instructions=[] + user_instructions=["do not use the letter e","only use the letter e"] ) + print_result("Iteration Limit Test (-1 = unlimited)", result) assert "best_response" in result @pytest.mark.integration def test_empty_context_and_instructions(my_llm, base_config): + """Ensure pipeline works with no context, instructions, or system prompt.""" result = run_reprompting_pipeline( - user_query="What's the policy?", + user_query="Testing with empty context, instructions, and system prompt", context="", llm_fn=my_llm, reprompting_config=base_config, user_instructions=[] ) + print_result("Empty Context & Instructions Test", result) assert "best_response" in result @pytest.mark.integration def test_no_telemetry(my_llm, config_without_telemetry): + """Confirm telemetry and summary are excluded when disabled in config.""" result = run_reprompting_pipeline( - user_query="What's the policy?", - context="Context for telemetry disabled run", + user_query="I keep getting 401 errors when trying to connect to your API. What should I check first?", + context="[SECTION] API Integration Troubleshooting Guide – Version 2.1 [SECTION] Document Ref: API-TS-2025-07 / Issued March 2025 [SECTION] Step 1: Verify Authentication Details [SECTION] To resolve 401 errors, first check these key items: [SECTION] - Ensure your API key has exactly 32 characters [SECTION] - Confirm the key is active in your Developer Portal account [SECTION] - Check that your IP address is whitelisted if required [SECTION] Step 2: Gather Required Information [SECTION] For support cases, prepare: [SECTION] - Screenshot of the error message [SECTION] - Recent API call logs [SECTION] - Your account ID and integration details [SECTION] Step 3: Submit Support Request [SECTION] You can submit your request through: [SECTION] - The Developer Portal ticket system (fastest response) [SECTION] - Email to api-support@company.com with 401 Error in subject [SECTION] Typical response time is 2 business days. [SECTION] Step 4: After Resolution [SECTION] Once fixed: [SECTION] - Update your integration settings [SECTION] - Keep records of the troubleshooting process [SECTION] For immediate help: [SECTION] Call 1-800-API-HELP (24/7 for Priority customers) [SECTION] Email: api-support@company.com[SECTION] API Rate Limit and Throttling Policy – 2025 Update [SECTION] Document Ref: API-POL-2025-07 / Effective March 2025 [SECTION] Section 1: Standard Rate Limits [SECTION] The following rate limits apply to all API endpoints unless otherwise specified in your service tier agreement: [SECTION] - Free Tier: 100 requests per minute, 1,000 requests per day [SECTION] - Business Tier: 500 requests per minute, 10,000 requests per day [SECTION] - Enterprise Tier: Custom limits negotiated per contract [SECTION] Section 2: Throttling Behavior [SECTION] When limits are exceeded: [SECTION] 1. First violation: API returns HTTP 429 (Too Many Requests) with Retry-After header [SECTION] 2. Subsequent violations within 24 hours: Temporary suspension for 1 hour [SECTION] 3. Chronic violations (3+ in 7 days): Account review and potential permanent rate reduction [SECTION] Section 3: Best Practices for Avoiding Throttling [SECTION] To maintain optimal API performance: [SECTION] 1. Implement exponential backoff when receiving 429 responses [SECTION] 2. Cache responses where possible (ETag headers supported on all GET endpoints) [SECTION] 3. Use batch endpoints instead of individual calls for bulk operations [SECTION] 4. Monitor usage via the X-RateLimit-Remaining header [SECTION] Section 4: Consequences of Policy Violations [SECTION] Repeated throttling may result in: [SECTION] 1. Temporary API key revocation [SECTION] 2. Mandatory migration to higher service tier [SECTION] 3. Suspension of account privileges pending review [SECTION] Section 5: Monitoring and Alerts [SECTION] Configure usage alerts through: [SECTION] 1. Dashboard notifications (available in Account Settings) [SECTION] 2. Webhook integrations (documented in API Guide Section 12.4) [SECTION] 3. Email warnings at 75% and 90% of daily limits[SECTION] API Rate Limit and Throttling Policy – Version 2.1 [SECTION] Effective Date: March 2025 [SECTION] This document outlines the rate limits, throttling policies, and escalation procedures for the Enterprise API tier. All API calls are subject to these limits unless otherwise specified in a signed Service Level Agreement (SLA). [SECTION] ## Rate Limit Tiers [SECTION] - **Standard Tier:** 1,000 requests per minute (RPM) across all endpoints [SECTION] - **High-Capacity Tier:** 5,000 RPM, available for an additional $200/month fee [SECTION] - **Burst Capacity:** Temporary spikes up to 2x your tier limit for 5-minute intervals, max twice per hour [SECTION] ## Throttling Behavior [SECTION] When limits are exceeded: [SECTION] - First violation: API returns HTTP 429 with Retry-After header (typically 30 seconds) [SECTION] - Repeated violations within 1 hour: 15-minute cool-down period enforced [SECTION] - Chronic violations (3+ incidents/day): Account review and potential downgrade to Standard Tier [SECTION] ## Urgent Limit Increase Process [SECTION] Follow these steps to resolve your rate limit issue: [SECTION] 1. **Submit Request:** Log into the API Dashboard and navigate to Manage Quotas [SECTION] 2. **Select Priority:** Choose Urgent and provide: [SECTION] - Business justification for the increase [SECTION] - Expected call volume during peak hours [SECTION] - Required duration (maximum 72 hours) [SECTION] 3. **Payment:** Submit the $75 expedited processing fee [SECTION] 4. **Activation:** Approved increases take effect within 2 hours of submissionSECTION] ## Consequences of Not Following Process [SECTION] - Unapproved workarounds may trigger account suspension [SECTION] - Repeated urgent requests may require SLA upgrade [SECTION] - All limit changes are logged and audited [SECTION] ## Recommended Action [SECTION] For immediate relief while waiting for approval: [SECTION] - Implement client-side retry logic with exponential backoff [SECTION] - Distribute calls across multiple API keys if available [SECTION] - Schedule non-critical requests during off-peak hours [SECTION] ## Support Resources [SECTION] - Emergency Support: api-support@example.com (Subject: URGENT - Rate Limit) [SECTION] - Real-time Monitoring: api.example.com/status [SECTION] - Documentation: docs.example.com/api/rate-limits [SECTION] ## Note on Eligibility [SECTION] Temporary increases are granted based on system capacity and historical usage patterns. Approval is not guaranteed for accounts with frequent violation history.[SECTION] API Rate Limit and Throttling Policy – 2025 Update [SECTION] Document Ref: API-POL-2025-07 / Effective March 2025 [SECTION] Section 1: Standard Rate Limits [SECTION] The following rate limits apply to all API endpoints unless otherwise specified in your service tier agreement: [SECTION] - Free Tier: 100 requests per minute, 1,000 requests per day [SECTION] - Business Tier: 500 requests per minute, 10,000 requests per day [SECTION] - Enterprise Tier: Custom limits negotiated per contract [SECTION] Section 2: Throttling Behavior [SECTION] When limits are exceeded: [SECTION] 1. First violation: API returns HTTP 429 (Too Many Requests) with Retry-After header [SECTION] 2. Subsequent violations within 24 hours: Temporary suspension for 1 hour [SECTION] 3. Chronic violations (3+ in 7 days): Account review and potential permanent rate reduction [SECTION] Section 3: Best Practices for Avoiding Throttling [SECTION] To maintain optimal API performance: [SECTION] 1. Implement exponential backoff when receiving 429 responses [SECTION] 2. Cache responses where possible (ETag headers supported on all GET endpoints) [SECTION] 3. Use batch endpoints instead of individual calls for bulk operations [SECTION] 4. Monitor usage via the X-RateLimit-Remaining header [SECTION] Section 4: Consequences of Policy Violations [SECTION] Repeated throttling may result in: [SECTION] 1. Temporary API key revocation [SECTION] 2. Mandatory migration to higher service tier [SECTION] 3. Suspension of account privileges pending review [SECTION] Section 5: Monitoring and Alerts [SECTION] Configure usage alerts through: [SECTION] 1. Dashboard notifications (available in Account Settings) [SECTION] 2. Webhook integrations (documented in API Guide Section 12.4) [SECTION] 3. Email warnings at 75% and 90% of daily limits[SECTION] API Rate Limit Enforcement Policy – California Department of Technology (2025 Revision) [SECTION] Document Ref: CDT-API-2025-09 / Effective March 1, 2025 [SECTION] Section 1: Rate Limit Thresholds [SECTION] All API endpoints enforce the following limits per client IP: [SECTION] - Standard Tier: 100 requests per minute [SECTION] - Elevated Tier: 500 requests per minute (requires Form API-T2 submitted 5 business days in advance) [SECTION] - Emergency Tier: 1,000 requests per minute (requires Form API-EMG with justification; valid for 72 hours) [SECTION] Section 2: Violation Consequences [SECTION] Exceeding rate limits triggers these automated responses: [SECTION] 1. First violation: HTTP 429 response with Retry-After header (60 seconds) [SECTION] 2. Second violation within 24 hours: 15-minute suspension [SECTION] 3. Third violation within 7 days: Account review and potential permanent blacklisting [SECTION] Section 3: Immediate Resolution Steps [SECTION] If your API access is suspended: [SECTION] 1. Check your request logs for spikes using CDT API Monitor (Form API-MON required for access) [SECTION] 2. Implement exponential backoff with jitter in your client code [SECTION] 3. Submit Form API-RES with: [SECTION] a. Incident timeline [SECTION] b. Corrective action plan [SECTION] c. Client IP ranges needing whitelisting [SECTION] Section 4: Permanent Blacklist Appeals [SECTION] To contest a blacklisting decision: [SECTION] 1. File Form API-APL within 10 business days [SECTION] 2. Provide technical documentation proving compliance with: [SECTION] a. California Code §11546.45 (API Fair Use) [SECTION] b. CDT Technical Bulletin 2025-7 (Throttling Best Practices) [SECTION] 3. Await review by the API Governance Board (5-10 business days) [SECTION] Note: Emergency service applications may qualify for expedited review if submitting Form API-EMG with wildfire response documentation.[SECTION] API Rate Limit Policy – Enterprise Developer Portal [SECTION] Document Ref: API-POL-2025-03 / Effective June 2025 [SECTION] Section 1: Understanding Your Rate Limit Issue [SECTION] Your application hitting rate limits during peak hours is a common challenge. Let's walk through the steps to resolve this while maintaining API access. [SECTION] Section 2: Immediate Actions [SECTION] 1. Review your API-LOG-78 reports to identify: [SECTION] * Which endpoints are exceeding limits [SECTION] * Time patterns of high traffic [SECTION] 2. Implement request throttling per Technical Bulletin API-TB-104 [SECTION] 3. For temporary relief, submit Form API-RL-22 for a 72-hour limit increase [SECTION] Section 3: Long-Term Solutions [SECTION] To permanently increase your rate limits: [SECTION] 1. Submit Form API-HC-45 with: [SECTION] * Business justification for higher limits [SECTION] * 30 days of API-LOG-78 reports [SECTION] 2. Our team will review within 5 business days [SECTION] Section 4: Best Practices [SECTION] * Spread high-volume requests evenly throughout the day [SECTION] * Cache responses where possible [SECTION] * Consider upgrading to Enterprise Tier (5,000 RPM) [SECTION] Section 5: What to Avoid [SECTION] Repeated violations may lead to: [SECTION] * Temporary API key suspension [SECTION] * Mandatory compliance review (Form API-COMP-19) [SECTION] * Service tier downgrade [SECTION] Section 6: Recommended Next Steps [SECTION] We recommend starting with Form API-RL-22 for immediate relief while preparing your materials for a permanent tier upgrade. Our support team is available to review your API-LOG-78 reports if needed.[SECTION] API Service Level Agreement – Version 2.1 [SECTION] Effective Date: March 15, 2025 [SECTION] Section 1: Service Availability Standards [SECTION] The API maintains 99.9% monthly uptime excluding scheduled maintenance. Downtime incidents exceeding 30 consecutive minutes qualify for service credit compensation under Section 7. [SECTION] Section 2: Incident Reporting Protocol [SECTION] To report 503 errors: [SECTION] 1. Document the incident with: [SECTION] - Exact timestamps (UTC) [SECTION] - Affected endpoint URLs [SECTION] - HTTP response headers [SECTION] 2. Complete Form API-INC-2025 (available in Developer Portal > Support) [SECTION] - Attach redacted error logs [SECTION] - Include business impact assessment [SECTION] 3. Submit within 60 minutes of first occurrence for priority handling [SECTION] Section 3: Investigation Timeline [SECTION] Upon submission: [SECTION] 1. Initial response within 15 minutes (email confirmation with Case ID) [SECTION] 2. Severity assessment using Priority Matrix API-PM-2025 within 30 minutes [SECTION] 3. Hourly status updates posted to Case ID portal [SECTION] Section 4: Resolution Procedures [SECTION] For confirmed outages: [SECTION] 1. Emergency patch deployment within 4 hours for Severity 1 incidents [SECTION] 2. Full root cause analysis report within 3 business days [SECTION] 3. Post-mortem review available upon request (Form API-PM-2025) [SECTION] Section 5: Compensation Policy [SECTION] Service credits apply as follows: [SECTION] - 5% of monthly fee for 30-59 minutes downtime [SECTION] - 10% for 1-2 hours [SECTION] - 15% for 2-4 hours [SECTION] Note: Credits require submission of Form API-CR-2025 within 7 calendar days. [SECTION] Section 6: Penalties for False Reports [SECTION] Misrepresented incidents may result in: [SECTION] - Suspension of incident reporting privileges for 30 days [SECTION] - Forfeiture of accrued service credits [SECTION] - Administrative fee of $250 per invalid claim [SECTION] Section 7: Emergency Contacts [SECTION] For unresolved Severity 1 incidents after 2 hours: [SECTION] 1. Primary: api-emergency@company.com (monitored 24/7) [SECTION] 2. Secondary: +1-800-555-API1 (follow voice prompts for engineer dispatch) [SECTION] 3. Escalation: File Form API-ESC-2025 with VP of Engineering CC [SECTION] Section 8: Preventive Measures [SECTION] Recommended best practices: [SECTION] - Implement exponential backoff with jitter [SECTION] - Monitor status.company.com for real-time updates [SECTION] - Maintain fallback endpoints per API-FB-2025 guidelines[SECTION] API Usage and Rate Limit Policy – Version 2025.1 [SECTION] We understand hitting rate limits can disrupt your workflow—let's review your options to resolve this. [SECTION] SECTION 1: CURRENT LIMITS AND UPGRADE PATHS [SECTION] Your Free Tier currently allows: [SECTION] - 100 requests per minute [SECTION] - 5,000 requests per day [SECTION] To increase these limits, consider: [SECTION] Option 1: Basic Tier ($49/month) [SECTION] - 500 requests per minute [SECTION] - 25,000 requests per day [SECTION] - Immediate activation via Developer Portal > Billing [SECTION] Option 2: Enterprise Tier [SECTION] - Custom limits tailored to your needs [SECTION] - Requires signed agreement (Form API-ENT-2025) [SECTION] - Contact sales@company.com for consultation [SECTION] SECTION 2: TEMPORARY LIMIT INCREASE [SECTION] If you need short-term relief: [SECTION] 1. Submit Form API-LIMIT-REQ through Developer Portal [SECTION] 2. Provide: [SECTION] - Technical justification (e.g., expected traffic spikes) [SECTION] - Duration needed (max 30 days) [SECTION] 3. Typical approval time: 2 business days [SECTION] SECTION 3: AVOIDING FUTURE ISSUES [SECTION] Best practices we recommend: [SECTION] - Implement exponential backoff (sample code in Dev Docs Section 4.3) [SECTION] - Cache responses using ETag headers [SECTION] - Monitor usage via Dashboard > API Analytics [SECTION] SECTION 4: IMPORTANT NOTES [SECTION] - Repeated violations (5+/month) may trigger account review [SECTION] - Emergency after-hours support: Submit Priority Ticket with 'Rate Limit' tag [SECTION] - Full policy details available in Document API-POL-2025.1 [SECTION] SECTION 5: IMMEDIATE HELP [SECTION] For urgent assistance: [SECTION] - Live chat: Developer Portal > Support [SECTION] - Phone: 1-800-555-API1 (Mon-Fri 9AM-5PM ET) [SECTION] Remember: Our team is here to help you scale efficiently while maintaining system stability for all users", llm_fn=my_llm, reprompting_config=config_without_telemetry, - user_instructions=[] + user_instructions=["Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)","Provide a detailed, ordered explanation of a process with at least three sequential steps.","Avoid expressions of uncertainty about company policies and eliminate vague or speculative phrases (e.g., “I think we cover that”)."] ) + print_result("No Telemetry Test", result) assert "telemetry" not in result assert "summary" not in result @pytest.mark.integration def test_no_system_prompt(my_llm, base_config): + """Test behavior when system prompt is excluded.""" result = run_reprompting_pipeline( - user_query="What's the policy?", - context="Context for telemetry disabled run", + user_query="What penalties can credit bureaus face if they don’t fix errors on my report, and how do I make sure they take my dispute seriously?", + context="[SECTION] California Credit Reporting & Dispute Resolution Policy – 2025 Update [SECTION] Document Ref: CA-CRDP-2025-09 / Effective January 1, 2025 [SECTION] Section 1: Credit Bureau Responsibilities [SECTION] Credit reporting agencies must correct errors on your report within 30 days. If they fail to do so, they may face penalties under state and federal law, including fines and required corrections. [SECTION] Section 2: How to File a Dispute [SECTION] Follow these steps to ensure your dispute is processed correctly: [SECTION] 1. Get your credit reports from all three bureaus using AnnualCreditReport.com or Form CR-REQUEST-2025 [SECTION] 2. Complete Form CA-DISPUTE-9, available on the DFPI website, including: [SECTION] • Your personal information in Section 3A [SECTION] • Details about each error in Section 4B [SECTION] • Supporting documents like bank statements [SECTION] 3. Submit your dispute online through the secure portal or by certified mail [SECTION] Section 3: What Happens Next [SECTION] After you file: [SECTION] 1. You'll receive a confirmation letter within 5 business days [SECTION] 2. The bureau will investigate and send results within 30 days [SECTION] 3. They must either correct the error, verify it's accurate, or remove the item [SECTION] Section 4: If the Error Isn't Fixed [SECTION] If the bureau doesn't correct a verified error: [SECTION] 1. File a complaint with the DFPI within 60 days using Form DFPI-CR-7 [SECTION] 2. Contact the Federal Trade Commission for assistance [SECTION] 3. You may have the right to take legal action [SECTION] Section 5: Getting Help Quickly [SECTION] For urgent situations like mortgage applications: [SECTION] • Call the DFPI Dispute Hotline at 1-800-555-REPORT (option 2) [SECTION] • Submit Form CR-EXPEDITE with proof of urgency [SECTION] • Visit a DFPI office by appointment [SECTION] Note: There may be a $25 fee if you dispute the same item more than twice. Medical debt disputes require extra documentation.[SECTION] California Credit Reporting Compliance Policy – FCRA Section 605 Enforcement [SECTION] Document Ref: CRCP-2025-09 / Effective Immediately [SECTION] Section 1: FCRA Violation Penalties Under California Law [SECTION] The Fair Credit Reporting Act (FCRA) violations in California are subject to the following penalties: [SECTION] - **Incorrect Reporting (FCRA §605(a)):** $2,500 per violation, with additional civil penalties up to $10,000 for willful non-compliance. [SECTION] - **Failure to Investigate Disputes (FCRA §611):** Mandatory $1,000 penalty per unresolved dispute, plus actual damages if litigation ensues. [SECTION] - **Unauthorized Access (FCRA §604):** Statutory damages of $3,000 per instance, plus potential criminal charges under California Penal Code 502(c). [SECTION] Section 2: Mandatory Corrective Actions [SECTION] Upon identification of an FCRA violation, regulated entities must: [SECTION] 1. Submit Form CR-25 (Credit Reporting Correction Notice) to the California Department of Financial Protection and Innovation (DFPI) within 5 business days. [SECTION] 2. Provide corrected information to all affected consumers via certified mail (Form CR-30) within 10 business days. [SECTION] 3. File an attestation of compliance (Form CR-35) with the CFPB within 15 business days, including: [SECTION] - Copies of corrected consumer reports [SECTION] - Proof of consumer notification [SECTION] - Internal audit documentation [SECTION] Section 3: Consumer Eligibility for Remedies [SECTION] Consumers may file claims if they meet these criteria: [SECTION] - Demonstrated financial harm via bank statements showing denied credit applications or increased interest rates. [SECTION] - Timely submission of Form CR-40 (Consumer Dispute Affidavit) within 60 days of violation discovery. [SECTION] - Documentation of at least two unsuccessful dispute attempts with the credit bureau (retain copies of Form CR-45). [SECTION] Section 4: Enforcement Timeline [SECTION] - **Immediate Actions (0-5 days):** Credit bureaus must place fraud alerts or security freezes upon request (Form CR-50). [SECTION] - **Investigation Phase (30 days):** Regulated entities must complete dispute investigations per FCRA §611(a)(1). [SECTION] - **Remediation Deadline (45 days):** All corrections must be reflected in consumer reports by this date. [SECTION] Section 5: Consequences of Non-Compliance [SECTION] Failure to adhere to these requirements results in: [SECTION] - Automatic referral to the California Attorney General's Office for enforcement action. [SECTION] - Suspension of credit reporting privileges for 90 days (extendable to 180 days for repeat violations). [SECTION] - Mandatory participation in quarterly FCRA compliance audits for two years. [SECTION] Section 6: Contact Information [SECTION] For compliance questions or dispute submissions: [SECTION] DFPI Credit Reporting Division: 1-800-555-7890 [SECTION] Email: cr.compliance@dfpi.ca.gov [SECTION] Overnight Mail: DFPI – CR Unit, 1500 11th Street, Sacramento, CA 95814[SECTION] California Credit Reporting Policy – 2025 Consumer Rights Update [SECTION] Document Ref: CCRP-2025-09 / Effective March 2025 [SECTION] Section 1: Requesting Your Credit Report [SECTION] California residents may request free credit reports under the following conditions: [SECTION] - **Annual Request**: One free report per year from each major bureau (Equifax, Experian, TransUnion) via AnnualCreditReport.com or Form CR-22. [SECTION] - **Additional Requests**: Free reports are available if: [SECTION] * You’ve been denied credit, employment, or housing within the last 60 days (submit denial letter with Form CR-25) [SECTION] * You’re a victim of identity theft (submit police report or FTC affidavit with Form CR-28) [SECTION] * You’re unemployed and plan to seek employment within 90 days (submit unemployment verification with Form CR-30) [SECTION] Section 2: Disputing Errors [SECTION] To dispute inaccuracies on your credit report: [SECTION] 1. **Document the Error**: Identify the incorrect item and gather supporting evidence (e.g., bank statements, payment confirmations). [SECTION] 2. **Submit Dispute**: File online through the credit bureau’s dispute portal or mail Form CR-40 with: [SECTION] * Copy of your credit report with errors circled [SECTION] * Proof of identity (CA driver’s license or state ID) [SECTION] * Supporting documentation [SECTION] 3. **Await Investigation**: Bureaus must respond within 30 days (45 days if submitting additional evidence later). [SECTION] Section 3: HIPAA-Related Medical Debt Reporting [SECTION] Under HIPAA Privacy Rule §164.528, medical debt reporting must comply with: [SECTION] - **Consent Requirement**: Providers must obtain written consent (Form HIPAA-15) before reporting medical debt to credit bureaus. [SECTION] - **Dispute Process**: If medical debt appears without consent, submit Form CR-45 to the bureau with a copy of the unsigned HIPAA-15. [SECTION] - **Removal Timeline**: Unauthorized medical debt must be removed within 5 business days of dispute receipt. [SECTION] Section 4: Contact Information [SECTION] For credit report assistance in California: [SECTION] - **Equifax**: 1-800-685-1111 | PO Box 740241, Atlanta, GA 30374 [SECTION] - **Experian**: 1-888-397-3742 | PO Box 4500, Allen, TX 75013 [SECTION] - **TransUnion**: 1-800-916-8800 | PO Box 2000, Chester, PA 19016 [SECTION] - **CA Attorney General’s Office**: 1-800-952-5225 | credit.reports@doj.ca.gov [SECTION] - **HIPAA Complaints**: Submit Form OCR-200 to the U.S. Department of Health and Human Services [SECTION] Section 5: Penalties for Non-Compliance [SECTION] Violations of credit reporting laws may result in: [SECTION] - **Bureau Penalties**: $2,500 per willful violation under the FCRA [SECTION] - **Provider Penalties**: Up to $50,000 per HIPAA violation for unauthorized medical debt reporting [SECTION] - **Consumer Remedies**: Actual damages plus attorney fees for successful lawsuits [SECTION] Note: Retain copies of all correspondence for at least 3 years. Dispute status can be checked online or by calling the bureau’s toll-free number.", llm_fn=my_llm, reprompting_config=base_config, user_instructions=["use the letter e only", "do not use the letter e"] ) + print_result("No System Prompt Test", result) assert "best_response" in result @pytest.mark.integration def test_with_system_prompt(my_llm, base_config): + """Test behavior when a system prompt is explicitly provided.""" result = run_reprompting_pipeline( - user_query="What's the policy?", - context="Context for telemetry disabled run", + user_query="Can I dispute my background check results if they’re wrong?", + context="[SECTION] California Employment Background Check Dispute Process – FCRA Compliance [SECTION] Effective: July 2025 / Policy Ref: BGC-2025-07 [SECTION] This document outlines the formal dispute procedure for inaccurate background check reports under Fair Credit Reporting Act (FCRA) §611 and California Civil Code §1786.16. [SECTION] SECTION 1: ELIGIBILITY REQUIREMENTS [SECTION] You may dispute your background check report if: [SECTION] - The report contains factual errors (e.g., incorrect employment dates, misattributed criminal records, or expired violations) [SECTION] - The disputed information falls within FCRA's 7-year reporting period (10 years for positions with salaries exceeding $125,000 annually) [SECTION] - You have not previously disputed the same item within the past 12 months [SECTION] SECTION 2: DISPUTE SUBMISSION PROCESS [SECTION] Step 1: Documentation Preparation [SECTION] - Complete Form BGC-2025-D (Dispute Request) with: [SECTION] * Notarized statement of inaccuracy [SECTION] * Supporting evidence (pay stubs, court disposition forms, or government-issued ID) [SECTION] * For healthcare positions: current medical license (Form MC-114) and malpractice insurance verification [SECTION] Step 2: Submission Methods [SECTION] - Secure Online Portal: Upload documents at bgcdispute.ca.gov (Case Type 45B) [SECTION] - Certified Mail: Send to California Background Check Bureau, PO Box 980, Sacramento, CA 95812 [SECTION] - In-Person: Submit at any California Department of Consumer Affairs office with appointment (Form APT-2025 required) [SECTION] Step 3: Processing Timeline [SECTION] - Acknowledgement issued within 3 business days via Form BGC-2025-R [SECTION] - Investigation completed within 30 calendar days (45 days for complex cases involving multiple jurisdictions) [SECTION] - Corrected reports distributed to you and requesting employer within 5 business days of resolution [SECTION] SECTION 3: CONSEQUENCES OF NON-COMPLIANCE [SECTION] - Incomplete submissions will be rejected and require re-filing (Form BGC-2025-RF) with $25 processing fee [SECTION] - Frivolous disputes (more than 3 in 12 months) may result in 6-month filing suspension [SECTION] - Employment applications may be automatically denied if dispute isn't resolved before employer's decision deadline [SECTION] SECTION 4: EXAMPLE SCENARIOS [SECTION] Example 1: A report lists a dismissed misdemeanor from 2022. Submit Form BGC-2025-D with court dismissal paperwork (Form CR-180) for automatic removal. [SECTION] Example 2: For incorrect drug test results, include lab retest documentation (Form DT-114) and chain-of-custody records. [SECTION] SECTION 5: CONTACT INFORMATION [SECTION] For assistance: [SECTION] - Phone: 1-800-555-1234 (Monday-Friday, 8 AM to 5 PM PST) [SECTION] - Email: bgc.disputes@ca.gov (Response within 2 business days) [SECTION] - In-Person: Schedule appointments using Form APT-2025 at approved locations [SECTION] Note: All disputes are subject to audit under FCRA §609 and may require additional verification. Fraudulent submissions may result in legal action under California Penal Code §532.", llm_fn=my_llm, reprompting_config=base_config, user_instructions=["use the letter e only", "do not use the letter e", "use a neutral tone"], system_prompt="this is a system prompt" ) + print_result("With System Prompt Test", result) assert "best_response" in result assert "telemetry" in result assert "summary" in result From e7a4410de11e8bdd45998adcfbd449549587d9f8 Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Wed, 30 Jul 2025 10:49:23 -0700 Subject: [PATCH 03/10] cleaning up toxicity visbility in telemetry (scores, response_feedback). updating residual error score calculation to have no penalty for adhereed instructions (follow probability >= 0.5) as per Alex's recommendation. also updated the description of a test case --- aimon/reprompting_api/pipeline.py | 7 +-- aimon/reprompting_api/telemetry.py | 2 +- .../tests/test_reprompting_cases.py | 6 +-- aimon/reprompting_api/utils.py | 44 +++++++++---------- 4 files changed, 29 insertions(+), 30 deletions(-) diff --git a/aimon/reprompting_api/pipeline.py b/aimon/reprompting_api/pipeline.py index 61de0e8..13cd7f1 100644 --- a/aimon/reprompting_api/pipeline.py +++ b/aimon/reprompting_api/pipeline.py @@ -1,7 +1,7 @@ from aimon.reprompting_api.config import RepromptingConfig, StopReasons from aimon.reprompting_api.telemetry import TelemetryLogger from aimon.reprompting_api.reprompter import Reprompter -from aimon.reprompting_api.utils import toxicity_check, get_failed_instructions_count, get_failed_instructions, get_residual_error_score +from aimon.reprompting_api.utils import toxicity_check, get_failed_instructions_count, get_failed_instructions, get_residual_error_score, get_failed_toxicity_instructions from aimon import Detect import time import random @@ -326,9 +326,10 @@ def get_response_feedback(self, result): """ scores = { "groundedness": result.detect_response.groundedness.get("score", 0.0), - "instruction_adherence": result.detect_response.instruction_adherence.get("score", 0.0) + "instruction_adherence": result.detect_response.instruction_adherence.get("score", 0.0), + "toxicity": result.detect_response.toxicity.get("score", 0.0) } - feedback = get_failed_instructions(result) + feedback = get_failed_instructions(result) + get_failed_toxicity_instructions(result) return scores, feedback def _build_corrective_prompt(self, payload, result): diff --git a/aimon/reprompting_api/telemetry.py b/aimon/reprompting_api/telemetry.py index a301308..1d408c2 100644 --- a/aimon/reprompting_api/telemetry.py +++ b/aimon/reprompting_api/telemetry.py @@ -51,7 +51,7 @@ def emit( "residual_error": residual_error, "failed_instructions_count": failed_instructions_count, "stop_reason": stop_reason, - "promp_template": prompt, + "prompt_template": prompt, "response_text": response_text, } self.memory_store.append(telemetry) diff --git a/aimon/reprompting_api/tests/test_reprompting_cases.py b/aimon/reprompting_api/tests/test_reprompting_cases.py index 89587b6..5dfa5ea 100644 --- a/aimon/reprompting_api/tests/test_reprompting_cases.py +++ b/aimon/reprompting_api/tests/test_reprompting_cases.py @@ -88,7 +88,7 @@ def config_iteration_limit(): return_telemetry=True, return_aimon_summary=True, application_name="api_test", - max_iterations=-1, + max_iterations=1, ) # --- Helper to print results nicely --- @@ -132,7 +132,7 @@ def test_latency_limit(my_llm, config_high_latency): @pytest.mark.integration def test_iteration_limit(my_llm, config_iteration_limit): - """Test behavior when max_iterations is unlimited (-1).""" + """Test behavior when max_iterations is 1.""" result = run_reprompting_pipeline( user_query="Our systems are showing vulnerability alerts but we can't find the patch file in the vendor portal. What should we do?", system_prompt="Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)", @@ -141,7 +141,7 @@ def test_iteration_limit(my_llm, config_iteration_limit): reprompting_config=config_iteration_limit, user_instructions=["do not use the letter e","only use the letter e"] ) - print_result("Iteration Limit Test (-1 = unlimited)", result) + print_result("Iteration Limit Test (no re-prompting, only 1 iteration allowed)", result) assert "best_response" in result @pytest.mark.integration diff --git a/aimon/reprompting_api/utils.py b/aimon/reprompting_api/utils.py index 380ef87..e1144a8 100644 --- a/aimon/reprompting_api/utils.py +++ b/aimon/reprompting_api/utils.py @@ -133,33 +133,30 @@ def get_residual_error_score(result): Compute a normalized residual error score (0–1) based on: - Groundedness follow probabilities - Instruction adherence follow probabilities - - Toxicity failures (adds a strong penalty) + - Toxicity (inverted: 1 - follow_probability) Logic: - 1. Compute a base penalty using groundedness & adherence: - - Each instruction's penalty = (1 - p), doubled if p < 0.5. - - Average across all instructions for a base score. - 2. Add a flat toxicity penalty (+0.3) if any toxicity failures exist. - 3. Clamp the final score to [0,1]. - - Args: - result: AIMon detection result with `instruction_adherence`, `groundedness`, and `toxicity` sections. - - Returns: - float: Residual error score (0 = perfect, 1 = worst). The float is rounded to two decimal places. + 1. Collect follow probabilities for groundedness & adherence. + 2. For toxicity, use 1 - follow_probability (since high follow = low error). + 3. Compute a penalized average using the helper. + 4. Clamp the final score to [0,1]. """ - combined_probs = [ - item["follow_probability"] - for source in ["groundedness", "instruction_adherence"] - for item in getattr(result.detect_response, source, {}).get("instructions_list", []) - ] - base_penalty = penalized_average(combined_probs) if combined_probs else 0.0 + combined_probs = [] - toxicity_penalty = 0.3 if _count_toxicity_failures(result) > 0 else 0.0 + for source in ["groundedness", "instruction_adherence"]: + combined_probs.extend([ + item["follow_probability"] + for item in getattr(result.detect_response, source, {}).get("instructions_list", []) + ]) - residual_error_score = base_penalty + toxicity_penalty - residual_error_score = min(1.0, max(0.0, residual_error_score)) + # For toxicity, invert the follow probability + combined_probs.extend([ + 1 - item["follow_probability"] + for item in getattr(result.detect_response, "toxicity", {}).get("instructions_list", []) + ]) + residual_error_score = penalized_average(combined_probs) if combined_probs else 0.0 + residual_error_score = min(1.0, max(0.0, residual_error_score)) return round(residual_error_score, 2) @@ -167,7 +164,8 @@ def penalized_average(probs: List[float]) -> float: """ Compute a penalized average of follow probabilities. - Penalizes probabilities <0.5 more heavily by doubling their penalty. + Penalizes probabilities <0.5 more heavily by doubling their penalty. + Probabilities > 0.5 (passed instructions) recieve no penalty Args: probs (List[float]): A list of follow probabilities. @@ -178,7 +176,7 @@ def penalized_average(probs: List[float]) -> float: penalties = [] for p in probs: if p >= 0.5: - penalty = 1 - p + penalty = 0 else: penalty = (1 - p) * 2 # heavier penalty penalties.append(penalty) From dc068fded5c149008a5ea222fd8d7d8f47304a2c Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Wed, 30 Jul 2025 11:39:04 -0700 Subject: [PATCH 04/10] updating the success test case to include complete context and system prompt. --- .../reprompting_api/tests/test_reprompting_success.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/aimon/reprompting_api/tests/test_reprompting_success.py b/aimon/reprompting_api/tests/test_reprompting_success.py index 10cc66f..5a6d2e6 100644 --- a/aimon/reprompting_api/tests/test_reprompting_success.py +++ b/aimon/reprompting_api/tests/test_reprompting_success.py @@ -64,14 +64,13 @@ def test_successful_run(): ) logger.info("[Pipeline] Config prepared.") - user_query = "what are the drug tiers?" - context = "[SECTION] 📘 BlueShield Rx Policy Addendum: 2023–2025 ... (truncated for brevity)" + user_query = "What are the drug tiers?" + context = "[SECTION] 📘 BlueShield Rx Policy Addendum: 2023–2025 Commercial & Employer-Sponsored Plans [SECTION] Confidential – Not for external dissemination without compliance review. [SECTION] 🔹 Section 2.1.7 – Drug Coverage Eligibility Matrix [SECTION] Prescription drug eligibility is governed by a tiered, multi-variant benefit design informed by annual P&T Committee decisions, manufacturer rebates, CMS Part D benchmarking (when applicable), and employer-specific customizations. The following formulary tiers apply unless superseded by a group rider or conditional override: [SECTION] - **Tier 1 (Generic Core):** Includes FDA-approved AB-rated generics; requires no PA or ST, unless the member is flagged under the Risk Management Tier Hold (RMTH) protocol due to prior misuse. [SECTION] - **Tier 2 (Preferred Brand & Enhanced Generics):** Coverage dependent on documented trial/failure of Tier 1 alternatives unless contraindicated. Members in the Legacy Bridge plan must obtain both prescriber attestation and pharmacy alignment verification. [SECTION] - **Tier 3 (Non-Preferred & Specialty Entry):** May require dual-layer review if member has not met chronic condition enrollment criteria (CCE) in the last benefit year. Tier migration possible mid-cycle based on new formulary rules. [SECTION] - **Tier 4 (Specialty Injectables, Biologics, and Condition-Limited Agents):** Includes drugs subject to clinical pathway alignment; claims must be adjudicated through the PBM’s split-fulfillment logic unless the prescribing entity is credentialed as Tier 4-A. [SECTION] 🚫 Exception: Certain biosimilars classified under Tier 4 in national formularies may be covered at Tier 2 if dispensed under limited-distribution contracts, provided the prescribing facility participates in the 340B program **and** the member is flagged under Enhanced Affordability Priority (EAP). [SECTION] 🔁 **Prior Authorization (PA) Layering Logic** [SECTION] Drugs requiring PA are subject to a three-stage filter: [SECTION] 1. **Therapeutic Criteria Review (TCR)** – Clinical alignment with diagnosis and formulary path. [SECTION] 2. **Coverage Policy Sync (CPS)** – Matches requested use with plan sponsor coverage schema. [SECTION] 3. **Utilization Watch Flag (UWF)** – If triggered, a third-party medical director review is initiated (adds 2–4 business days). [SECTION] 💡 Exemplar: *Trulicity* (GLP-1 receptor agonist) [SECTION] - **Base Tier:** Tier 3 across most commercial plans [SECTION] - **Override Possibility:** Auto-lifts to Tier 2 under Metabolic Risk Bundling if member is concurrently enrolled in cardiac risk management AND insulin titration modules. [SECTION] - **Caveat:** Auto-injector version may still trigger UWF if prescribed without 90-day adherence documentation to metformin or contraindication to semaglutide. [SECTION] 🗂️ **Adjudication Complexity Notes** [SECTION] - Fill attempts at non-network or out-of-state pharmacies may default to full retail pricing, even if coverage is active. [SECTION] - Certain maintenance tier drugs can only be filled at 90-day intervals after two successful 30-day fills unless dispensed via SmartSync (auto-align refill system). [SECTION] - Claims using discount cards (e.g., manufacturer copay assistance) will not count toward deductible or out-of-pocket limits unless the pharmacy submits a Coordinated Adjudication Adjustment Request (CAAR). [SECTION] ⚠️ **Denials & Appeals** [SECTION] - If PA is denied, appeals must cite new clinical rationale. Re-submission of identical documentation will be auto-denied. [SECTION] - Members in Tier Restructuring Delay (TRD) periods due to employer override cannot file external appeals unless the drug is life-sustaining and not replaceable under Tier 1/2. [SECTION] - Denials on non-formulary drugs are not eligible for Tier Transition Program (TTP) unless covered during prior plan year with no lapse in coverage >30 days. [SECTION] 📊 **Plan Differences** [SECTION] - Standard, Enhanced, Platinum, and Concierge tiers each have different deductible-accumulation thresholds and copay structures. [SECTION] - For Platinum+ plans, Tier 3 copay is waived on first-time fills initiated post-discharge from an inpatient episode if coded using post-acute NDCs. [SECTION] 📣 Misc. Clarifications [SECTION] - The “Healthy Living Rewards” program, mentioned in new member packets, does not affect coverage or drug tier placement. It is a wellness initiative only. [SECTION] - Benefit year resets on Jan 1, but tier realignment occurs quarterly and may retroactively affect claims filled in the trailing 45-day buffer period. [SECTION] 🔒 REMINDER: Member Services guidance may reflect outdated tier assignments if formulary refreshes are in progress. Online lookup tools update in real time and take precedence during adjudication disputes." + system_prompt = "You are a knowledgeable but approachable healthcare benefits assistant. Your role is to help users understand BlueShield prescription drug policies by explaining terms and tiers in simple, clear, and user‑friendly language. Always prioritize accuracy and clarity over technical jargon." user_instructions = [ "Avoid overly technical or robotic phrasing; keep the tone human and accessible.", "Ensure the response is direct and professional, with minimal informal tone.", - "Translate or simplify technical details from the context into accurate, user-friendly explanations.", - "Don't use the letter e", - "only use the letter e" + "Translate or simplify technical details from the context into accurate, user-friendly explanations." ] logger.info(f"[Pipeline] User query: {user_query}") logger.info(f"[Pipeline] Context: {context[:100]}...") @@ -81,7 +80,7 @@ def test_successful_run(): result = run_reprompting_pipeline( llm_fn=my_llm, user_query=user_query, - system_prompt="here is a system prompt", + system_prompt= system_prompt, context=context, user_instructions=user_instructions, reprompting_config=config From c2bac4bc461492121c9085af32b7ab4e1fe69d78 Mon Sep 17 00:00:00 2001 From: Aanya Shah <66803590+ashah-aanya@users.noreply.github.com> Date: Wed, 30 Jul 2025 13:25:59 -0700 Subject: [PATCH 05/10] Adding a Colab notebook to guide re-promping pipeline integration and construct an example reprompting flow. --- re_prompting_pipeline_demo.ipynb | 450 +++++++++++++++++++++++++++++++ 1 file changed, 450 insertions(+) create mode 100644 re_prompting_pipeline_demo.ipynb diff --git a/re_prompting_pipeline_demo.ipynb b/re_prompting_pipeline_demo.ipynb new file mode 100644 index 0000000..390dda9 --- /dev/null +++ b/re_prompting_pipeline_demo.ipynb @@ -0,0 +1,450 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyOW+bJJBTfcLjz4nzXbAVpZ", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Automated Re-Prompting Pipeline Demo\n", + "This notebook walks through how to use AIMon's re-prompting pipeline to refine LLM outputs.\n", + "\n", + "With this pipeline, you can:\n", + "\n", + "* Unlock **GPT‑4o‑level performance** using lightweight 3–7B parameter models\n", + "* Boost **instruction adherence by ~22%**\n", + "* Minimize hallucinations while keeping responses fast\n", + "\n", + "**How it works:**\n", + "\n", + "![repromptingpipeline.png](data:image/png;base64,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)\n", + "\n", + "1. **Generate:** A base LLM produces an initial response.\n", + "2. **Detect:** AIMon’s IFE model evaluates the response for instruction adherence, hallucination, and toxicity.\n", + "3. **Re‑prompt:** If issues are detected, the pipeline generates a targeted corrective prompt.\n", + "4. **Refine:** The LLM revises its answer using this feedback, repeating until criteria are met or specified limits are reached.\n", + "\n", + "\n", + "**Goal:** \n", + "By the end, you'll know how to integrate the re‑prompting pipeline into your own workflows and tune it for different performance/quality needs. In this demo, we will use TogetherAI to call Mistral 7B. However, the pipeline is model‑ and framework‑agnostic so it is easy to apply to any black‑box LLM and integrate with your existing retrieval stack." + ], + "metadata": { + "id": "oFQnzqtuGDSV" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Prerequisites" + ], + "metadata": { + "id": "hORx_VHbKmt_" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Get your API keys\n", + "\n", + " AIMon: Instructions [available here](https://docs.aimon.ai/quickstart#1-api-key)\n", + "\n", + " TogetherAI: Get your TogetherAI API Key [available here](https://www.together.ai/)\n", + "\n", + " Once you obtained this keys, configure your `AIMON_API_KEY` and `TOGETHER_API_KEY` in Google Collab secrets and provide them notebook access. We will TogetherAI to facilitate LLM calls and AIMon to evaluate instruction adherence, groundedness, and toxicity of generated outputs to fuel iterative improvement." + ], + "metadata": { + "id": "Sh8290AOKvry" + } + }, + { + "cell_type": "markdown", + "source": [ + "2. Install the dependencies." + ], + "metadata": { + "id": "1aST8279LbKq" + } + }, + { + "cell_type": "code", + "source": [ + "%%capture\n", + "!pip install together --quiet\n", + "%cd /content\n", + "!rm -rf aimon-python-sdk\n", + "!git clone -b reprompting-api https://github.com/aimonlabs/aimon-python-sdk.git\n", + "%cd aimon-python-sdk\n", + "!pip install -e ." + ], + "metadata": { + "id": "0AYy5Ru2L18p" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "3. Load the API keys into environment variables using the following cell." + ], + "metadata": { + "id": "gOn6QGhJNMOs" + } + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "\n", + "# Import Colab Secrets userdata module.\n", + "from google.colab import userdata\n", + "\n", + "os.environ['TOGETHER_API_KEY'] = userdata.get('TOGETHER_API_KEY')\n", + "os.environ['AIMON_API_KEY'] = userdata.get('AIMON_API_KEY')" + ], + "metadata": { + "id": "pCgtl98mNL_D" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Step 1: Set up your LLM function\n", + "\n", + "To use the re‑prompting pipeline, you must provide your own Callable LLM function. This function acts as the connector between the pipeline and any black‑box model (e.g., TogetherAI, OpenAI, Anthropic, or a local model). In this case we are using Mistral7B via TogetherAI.\n", + "\n", + "The function should take in the following parameters:\n", + "\n", + "* **`recommended_prompt_template` (string.Template):** the corrective prompt template generated by the pipeline.\n", + "* **`system_prompt` (str):** system-level instructions or guidelines for model behavior.\n", + "* **`context` (str):** the contextual information or reference material relevant to the query. This is typically passed from a retrieval step or knowledge base.\n", + "* **`user_query` (str):** the user's query.\n", + "\n", + "**Return value:**\n", + "Your function must return a single string containing the model's generated response.\n", + "\n", + "How it works:\n", + "\n", + "1. Receive the corrective prompt as a string.Template.\n", + "\n", + "2. Substitute placeholders (system_prompt, context, user_query) into the template. You can alternatively implement your own template or modify the provided one for more control.\n", + "\n", + "3. Send the filled prompt to your chosen model (e.g., TogetherAI, OpenAI, Anthropic, local model).\n", + "\n", + "4. Return the model’s response as plain text.\n", + "\n", + "> Try swapping `model` for any Together-hosted model (e.g., 'mistralai/Mistral-7B-Instruct-v0.2'). You can also replace the whole block with any LLM call (OpenAI, Claude, HuggingFace, etc.)\n" + ], + "metadata": { + "id": "MhWcamP7PKZZ" + } + }, + { + "cell_type": "code", + "source": [ + "from string import Template\n", + "from together import Together\n", + "\n", + "TOGETHER_API_KEY = os.environ.get(\"TOGETHER_API_KEY\")\n", + "client = Together(api_key=TOGETHER_API_KEY)\n", + "\n", + "def my_llm(recommended_prompt_template: Template, system_prompt, context, user_query) -> str:\n", + "\n", + " # substitute placeholders in the pipeline-provided template with appropriate values\n", + " filled_prompt = recommended_prompt_template.substitute(\n", + " system_prompt=system_prompt,\n", + " context=context,\n", + " user_query=user_query\n", + " )\n", + "\n", + " # replace this block with any LLM call you want. (OpenAI, Claude, HuggingFace, etc.)\n", + " response = client.chat.completions.create(\n", + " model=\"google/gemma-3n-E4B-it\", # this can be any Together-hosted model (e.g., 'mistralai/Mistral-7B-Instruct-v0.2')\n", + " messages=[{\"role\": \"user\", \"content\": filled_prompt}],\n", + " max_tokens=256, # increase for longer outputs\n", + " temperature=0 # raise for more creative outputs\n", + " )\n", + "\n", + " # extract and return a string output\n", + " output = response.choices[0].message.content\n", + " return output" + ], + "metadata": { + "id": "XHYBsQHCQyCD" + }, + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Step 2: Set up AIMon's RepromptingConfig\n", + "\n", + "The RepromptingConfig object controls how the pipeline behaves. Here are some of the key parameters:\n", + "\n", + "* **`aimon_api_key` (str)** Your AIMon API key, used to call the Instruction‑Following Evaluation (IFE) model that scores and guides the LLM’s outputs. If not provided directly, the pipeline looks for the key in the AIMON_API_KEY environment variable.\n", + "\n", + "* **`return_telemetry` (bool)** If True, the pipeline returns a detailed JSON log of every iteration. This includes each draft response, feedback, and corrective prompt. Great for debugging or analyzing model behavior. Default False.\n", + "\n", + "* **`return_aimon_summary` (bool)** If True, the pipeline returns a short summary: \"[2 iterations, 0 failed instruction remaining].\" Default False.\n", + "\n", + "* **`max_iterations` (int)** Sets how many times the pipeline will attempt to refine the model’s output. For example, 3 means “1 initial response + up to 2 corrective re‑prompts.” 2-3 recommended. Default 2.\n", + "\n" + ], + "metadata": { + "id": "GZO6E9Nwf9sd" + } + }, + { + "cell_type": "code", + "source": [ + "from aimon.reprompting_api.config import RepromptingConfig\n", + "\n", + "config = RepromptingConfig(\n", + " aimon_api_key=os.getenv(\"AIMON_API_KEY\"),\n", + " return_telemetry=True,\n", + " return_aimon_summary=True,\n", + " max_iterations=3\n", + " )" + ], + "metadata": { + "id": "ZcsbXRnHixdC" + }, + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Step 3: Run the re-prompting pipeline" + ], + "metadata": { + "id": "SmvfimYSlSDT" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### 1. Define test inputs.\n", + "\n", + "Before running the pipeline, you need to provide:\n", + "\n", + "* **`user_query` (required):** The actual question or task for the model.\n", + "\n", + "* **`system_prompt`:** A high‑level role or behavior definition for the model.\n", + "\n", + "* **`context` (recommended):** Relevant background text for the model to reference (e.g., a document, policy, or knowledge base excerpt).\n", + "\n", + "* **`user_instructions` (recommended):** Specific, deterministic guidelines for how the response should be written. These are what AIMon uses to evaluate and iteratively improve the model’s output.\n", + "\n", + "> **Tip:** The more specific and deterministic your instructions, the more effective the re-prompting loop will be." + ], + "metadata": { + "id": "yn9PEGUrlz4Q" + } + }, + { + "cell_type": "code", + "source": [ + "user_query = \"All my loans are for graduate studies, at which date in the future are they forgiven?\"\n", + "system_prompt = \"You are a knowledgeable but approachable student loan advisor. Your role is to help borrowers understand complex federal repayment and forgiveness programs by breaking down policy details into clear, accurate, and accessible explanations. Always provide complete information necessary to answer the question, while maintaining a professional and neutral tone.\"\n", + "context = \"Income-Driven Repayment (IDR) plans help lower federal student loan payments based on income and family size, with four options available: REPAYE, PAYE, IBR, and ICR. REPAYE and PAYE require payments of 10% of discretionary income, with forgiveness after 20 years for undergraduate loans and 25 years for graduate loans. IBR varies between 10% and 15% based on when loans were taken, with forgiveness after 20 or 25 years, while ICR calculates payments as the lesser of 20% of discretionary income or a fixed 12-year repayment amount, with forgiveness after 25 years. Eligibility requires a verified FSA ID, recent income documentation, and annual recertification of income and family size; failure to recertify may increase payments and interest. Joint filers must include their spouse’s income unless separated, and only Direct Loans qualify unless others are consolidated. Private loans are ineligible, and borrowers in default must make satisfactory arrangements before enrolling.\"\n", + "user_instructions = [\n", + " \"Avoid overly technical or robotic phrasing; keep the tone human and accessible.\",\n", + " \"Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)\",\n", + " \"Response should not omit critical details needed to understand or answer the query\"\n", + "]" + ], + "metadata": { + "id": "Z4Qm_ME8nOKM" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### 2. Call run_reprompting_pipeline()\n", + "\n", + "\n", + "Now that the configuration and test inputs are ready, we can pass it along with our LLM function to the pipeline. This will:\n", + "\n", + "* Send the input to your chosen LLM.\n", + "\n", + "* Use AIMon’s detectors to evaluate instruction adherence, groundedness, and toxicity.\n", + "\n", + "* Automatically generate corrective prompts and iterate up to max_iterations." + ], + "metadata": { + "id": "OKSFSglArHpw" + } + }, + { + "cell_type": "code", + "source": [ + "from aimon.reprompting_api.runner import run_reprompting_pipeline\n", + "\n", + "result = run_reprompting_pipeline(\n", + " llm_fn=my_llm,\n", + " user_query=user_query,\n", + " system_prompt= system_prompt,\n", + " context=context,\n", + " user_instructions=user_instructions,\n", + " reprompting_config=config\n", + " )" + ], + "metadata": { + "id": "p7GtwY9Cra0e" + }, + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Step 4: View your improved generated text and telemetry!" + ], + "metadata": { + "id": "w6xyeUFJrnho" + } + }, + { + "cell_type": "code", + "source": [ + "import json\n", + "\n", + "print(\"\\n=== SUMMARY ===\")\n", + "print(result.get(\"summary\"))\n", + "print(\"\\n=== BEST RESPONSE ===\")\n", + "print(result[\"best_response\"])\n", + "print(\"\\n=== TELEMETRY ===\")\n", + "print(json.dumps(result.get(\"telemetry\"), indent=2))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AVke0epgru1d", + "outputId": "3efbdcc5-bbc0-42e3-b8a1-f4fa5a75e3a3" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "=== SUMMARY ===\n", + "2 iterations, 0 failed instructions remaining\n", + "\n", + "=== BEST RESPONSE ===\n", + "Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\n", + "\n", + "Here's a breakdown based on the IDR options available:\n", + "\n", + "* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\n", + "* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\n", + "* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\n", + "\n", + "**To determine the specific forgiveness date for your loans, I need a little more information:**\n", + "\n", + "1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under.\n", + "\n", + "=== TELEMETRY ===\n", + "[\n", + " {\n", + " \"iteration\": 1,\n", + " \"cumulative_latency_ms\": 49848.28877449036,\n", + " \"scores\": {\n", + " \"groundedness\": 1.0,\n", + " \"instruction_adherence\": 0.6666666666666666,\n", + " \"toxicity\": 0.0\n", + " },\n", + " \"response_feedback\": [\n", + " {\n", + " \"type\": \"instruction_adherence_failure\",\n", + " \"source\": \"instruction_adherence\",\n", + " \"instruction\": \"Response should not omit critical details needed to understand or answer the query\",\n", + " \"score\": 0.4688,\n", + " \"explanation\": \"The response omits key details such as eligibility requirements and the need for annual recertification, leaving important information out.\"\n", + " }\n", + " ],\n", + " \"residual_error\": 0.08,\n", + " \"failed_instructions_count\": 1,\n", + " \"stop_reason\": \"instructions_failed_continue_reprompting\",\n", + " \"prompt_template\": \"System:\\n${system_prompt}\\n\\nContext:\\n${context}\\n\\nUser Query:\\n${user_query}\",\n", + " \"response_text\": \"Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under (\"\n", + " },\n", + " {\n", + " \"iteration\": 2,\n", + " \"cumulative_latency_ms\": 105391.15405082703,\n", + " \"scores\": {\n", + " \"groundedness\": 1.0,\n", + " \"instruction_adherence\": 1.0,\n", + " \"toxicity\": 0.0\n", + " },\n", + " \"response_feedback\": [],\n", + " \"residual_error\": 0.0,\n", + " \"failed_instructions_count\": 0,\n", + " \"stop_reason\": \"all_instructions_adhered\",\n", + " \"prompt_template\": \"Original system prompt:\\n${system_prompt}\\n\\nRevise your previous response to this query:\\n${user_query}\\n\\nContext:\\n${context}\\n\\nPrevious response:\\nOkay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under (\\n\\nAlmost there. Just a few small fixes needed.\\n\\nFix the following:\\n\\n1. We are 53.12% confident that the following instruction was not followed:\\n\\u2192 Violated Instruction: \\\"Response should not omit critical details needed to understand or answer the query\\\"\\n\\u2192 Explanation: The response omits key details such as eligibility requirements and the need for annual recertification, leaving important information out.\\n\\n\\nPreserve correct content. Return only the revised output with no extra explanation.\\nYou did well on these instructions. It is important that you continue to follow these instructions:\\n- Avoid overly technical or robotic phrasing; keep the tone human and accessible.\\n- Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)\\n\",\n", + " \"response_text\": \"Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under.\"\n", + " }\n", + "]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Conclusion\n", + "\n", + "In this notebook, we demonstrated how to use AIMon’s Re‑prompting Pipeline to automatically improve LLM responses with targeted feedback. We covered:\n", + "\n", + "* Building a `my_llm` function to fill templated prompts and call any LLM.\n", + "\n", + "* Adjusting `RepromptingConfig` to control pipeline behavior.\n", + "\n", + "* Compiling test inputs, including `system_prompt`, `context`, `user_query`, and `user_instructions`.\n", + "\n", + "* Running the pipeline and reviewing the improved outputs.\n", + "\n", + "With these steps, you can integrate re‑prompting into your own workflows to make model outputs more accurate, consistent, and user‑aligned.\n", + "\n", + "For deeper insights into how re‑prompting improves instruction adherence across models and test cases, check out our blog post [link].\n", + "\n", + "To learn more about available configurations and advanced options, visit our documentation [link].\n", + "\n" + ], + "metadata": { + "id": "g7hpVaYWvkTQ" + } + } + ] +} \ No newline at end of file From 9b9c25a3c1c7be35141b96d0d25026e3890e7fe9 Mon Sep 17 00:00:00 2001 From: Aanya Shah <66803590+ashah-aanya@users.noreply.github.com> Date: Thu, 31 Jul 2025 11:55:10 -0700 Subject: [PATCH 06/10] Delete re_prompting_pipeline_demo.ipynbo Deleting Colab notebook demo as it is already linked elsewhere --- re_prompting_pipeline_demo.ipynb | 450 ------------------------------- 1 file changed, 450 deletions(-) delete mode 100644 re_prompting_pipeline_demo.ipynb diff --git a/re_prompting_pipeline_demo.ipynb b/re_prompting_pipeline_demo.ipynb deleted file mode 100644 index 390dda9..0000000 --- a/re_prompting_pipeline_demo.ipynb +++ /dev/null @@ -1,450 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "authorship_tag": "ABX9TyOW+bJJBTfcLjz4nzXbAVpZ", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Automated Re-Prompting Pipeline Demo\n", - "This notebook walks through how to use AIMon's re-prompting pipeline to refine LLM outputs.\n", - "\n", - "With this pipeline, you can:\n", - "\n", - "* Unlock **GPT‑4o‑level performance** using lightweight 3–7B parameter models\n", - "* Boost **instruction adherence by ~22%**\n", - "* Minimize hallucinations while keeping responses fast\n", - "\n", - "**How it works:**\n", - "\n", - "![repromptingpipeline.png](data:image/png;base64,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)\n", - "\n", - "1. **Generate:** A base LLM produces an initial response.\n", - "2. **Detect:** AIMon’s IFE model evaluates the response for instruction adherence, hallucination, and toxicity.\n", - "3. **Re‑prompt:** If issues are detected, the pipeline generates a targeted corrective prompt.\n", - "4. **Refine:** The LLM revises its answer using this feedback, repeating until criteria are met or specified limits are reached.\n", - "\n", - "\n", - "**Goal:** \n", - "By the end, you'll know how to integrate the re‑prompting pipeline into your own workflows and tune it for different performance/quality needs. In this demo, we will use TogetherAI to call Mistral 7B. However, the pipeline is model‑ and framework‑agnostic so it is easy to apply to any black‑box LLM and integrate with your existing retrieval stack." - ], - "metadata": { - "id": "oFQnzqtuGDSV" - } - }, - { - "cell_type": "markdown", - "source": [ - "### Prerequisites" - ], - "metadata": { - "id": "hORx_VHbKmt_" - } - }, - { - "cell_type": "markdown", - "source": [ - "1. Get your API keys\n", - "\n", - " AIMon: Instructions [available here](https://docs.aimon.ai/quickstart#1-api-key)\n", - "\n", - " TogetherAI: Get your TogetherAI API Key [available here](https://www.together.ai/)\n", - "\n", - " Once you obtained this keys, configure your `AIMON_API_KEY` and `TOGETHER_API_KEY` in Google Collab secrets and provide them notebook access. We will TogetherAI to facilitate LLM calls and AIMon to evaluate instruction adherence, groundedness, and toxicity of generated outputs to fuel iterative improvement." - ], - "metadata": { - "id": "Sh8290AOKvry" - } - }, - { - "cell_type": "markdown", - "source": [ - "2. Install the dependencies." - ], - "metadata": { - "id": "1aST8279LbKq" - } - }, - { - "cell_type": "code", - "source": [ - "%%capture\n", - "!pip install together --quiet\n", - "%cd /content\n", - "!rm -rf aimon-python-sdk\n", - "!git clone -b reprompting-api https://github.com/aimonlabs/aimon-python-sdk.git\n", - "%cd aimon-python-sdk\n", - "!pip install -e ." - ], - "metadata": { - "id": "0AYy5Ru2L18p" - }, - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "3. Load the API keys into environment variables using the following cell." - ], - "metadata": { - "id": "gOn6QGhJNMOs" - } - }, - { - "cell_type": "code", - "source": [ - "import os\n", - "\n", - "# Import Colab Secrets userdata module.\n", - "from google.colab import userdata\n", - "\n", - "os.environ['TOGETHER_API_KEY'] = userdata.get('TOGETHER_API_KEY')\n", - "os.environ['AIMON_API_KEY'] = userdata.get('AIMON_API_KEY')" - ], - "metadata": { - "id": "pCgtl98mNL_D" - }, - "execution_count": 7, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### Step 1: Set up your LLM function\n", - "\n", - "To use the re‑prompting pipeline, you must provide your own Callable LLM function. This function acts as the connector between the pipeline and any black‑box model (e.g., TogetherAI, OpenAI, Anthropic, or a local model). In this case we are using Mistral7B via TogetherAI.\n", - "\n", - "The function should take in the following parameters:\n", - "\n", - "* **`recommended_prompt_template` (string.Template):** the corrective prompt template generated by the pipeline.\n", - "* **`system_prompt` (str):** system-level instructions or guidelines for model behavior.\n", - "* **`context` (str):** the contextual information or reference material relevant to the query. This is typically passed from a retrieval step or knowledge base.\n", - "* **`user_query` (str):** the user's query.\n", - "\n", - "**Return value:**\n", - "Your function must return a single string containing the model's generated response.\n", - "\n", - "How it works:\n", - "\n", - "1. Receive the corrective prompt as a string.Template.\n", - "\n", - "2. Substitute placeholders (system_prompt, context, user_query) into the template. You can alternatively implement your own template or modify the provided one for more control.\n", - "\n", - "3. Send the filled prompt to your chosen model (e.g., TogetherAI, OpenAI, Anthropic, local model).\n", - "\n", - "4. Return the model’s response as plain text.\n", - "\n", - "> Try swapping `model` for any Together-hosted model (e.g., 'mistralai/Mistral-7B-Instruct-v0.2'). You can also replace the whole block with any LLM call (OpenAI, Claude, HuggingFace, etc.)\n" - ], - "metadata": { - "id": "MhWcamP7PKZZ" - } - }, - { - "cell_type": "code", - "source": [ - "from string import Template\n", - "from together import Together\n", - "\n", - "TOGETHER_API_KEY = os.environ.get(\"TOGETHER_API_KEY\")\n", - "client = Together(api_key=TOGETHER_API_KEY)\n", - "\n", - "def my_llm(recommended_prompt_template: Template, system_prompt, context, user_query) -> str:\n", - "\n", - " # substitute placeholders in the pipeline-provided template with appropriate values\n", - " filled_prompt = recommended_prompt_template.substitute(\n", - " system_prompt=system_prompt,\n", - " context=context,\n", - " user_query=user_query\n", - " )\n", - "\n", - " # replace this block with any LLM call you want. (OpenAI, Claude, HuggingFace, etc.)\n", - " response = client.chat.completions.create(\n", - " model=\"google/gemma-3n-E4B-it\", # this can be any Together-hosted model (e.g., 'mistralai/Mistral-7B-Instruct-v0.2')\n", - " messages=[{\"role\": \"user\", \"content\": filled_prompt}],\n", - " max_tokens=256, # increase for longer outputs\n", - " temperature=0 # raise for more creative outputs\n", - " )\n", - "\n", - " # extract and return a string output\n", - " output = response.choices[0].message.content\n", - " return output" - ], - "metadata": { - "id": "XHYBsQHCQyCD" - }, - "execution_count": 23, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### Step 2: Set up AIMon's RepromptingConfig\n", - "\n", - "The RepromptingConfig object controls how the pipeline behaves. Here are some of the key parameters:\n", - "\n", - "* **`aimon_api_key` (str)** Your AIMon API key, used to call the Instruction‑Following Evaluation (IFE) model that scores and guides the LLM’s outputs. If not provided directly, the pipeline looks for the key in the AIMON_API_KEY environment variable.\n", - "\n", - "* **`return_telemetry` (bool)** If True, the pipeline returns a detailed JSON log of every iteration. This includes each draft response, feedback, and corrective prompt. Great for debugging or analyzing model behavior. Default False.\n", - "\n", - "* **`return_aimon_summary` (bool)** If True, the pipeline returns a short summary: \"[2 iterations, 0 failed instruction remaining].\" Default False.\n", - "\n", - "* **`max_iterations` (int)** Sets how many times the pipeline will attempt to refine the model’s output. For example, 3 means “1 initial response + up to 2 corrective re‑prompts.” 2-3 recommended. Default 2.\n", - "\n" - ], - "metadata": { - "id": "GZO6E9Nwf9sd" - } - }, - { - "cell_type": "code", - "source": [ - "from aimon.reprompting_api.config import RepromptingConfig\n", - "\n", - "config = RepromptingConfig(\n", - " aimon_api_key=os.getenv(\"AIMON_API_KEY\"),\n", - " return_telemetry=True,\n", - " return_aimon_summary=True,\n", - " max_iterations=3\n", - " )" - ], - "metadata": { - "id": "ZcsbXRnHixdC" - }, - "execution_count": 24, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### Step 3: Run the re-prompting pipeline" - ], - "metadata": { - "id": "SmvfimYSlSDT" - } - }, - { - "cell_type": "markdown", - "source": [ - "#### 1. Define test inputs.\n", - "\n", - "Before running the pipeline, you need to provide:\n", - "\n", - "* **`user_query` (required):** The actual question or task for the model.\n", - "\n", - "* **`system_prompt`:** A high‑level role or behavior definition for the model.\n", - "\n", - "* **`context` (recommended):** Relevant background text for the model to reference (e.g., a document, policy, or knowledge base excerpt).\n", - "\n", - "* **`user_instructions` (recommended):** Specific, deterministic guidelines for how the response should be written. These are what AIMon uses to evaluate and iteratively improve the model’s output.\n", - "\n", - "> **Tip:** The more specific and deterministic your instructions, the more effective the re-prompting loop will be." - ], - "metadata": { - "id": "yn9PEGUrlz4Q" - } - }, - { - "cell_type": "code", - "source": [ - "user_query = \"All my loans are for graduate studies, at which date in the future are they forgiven?\"\n", - "system_prompt = \"You are a knowledgeable but approachable student loan advisor. Your role is to help borrowers understand complex federal repayment and forgiveness programs by breaking down policy details into clear, accurate, and accessible explanations. Always provide complete information necessary to answer the question, while maintaining a professional and neutral tone.\"\n", - "context = \"Income-Driven Repayment (IDR) plans help lower federal student loan payments based on income and family size, with four options available: REPAYE, PAYE, IBR, and ICR. REPAYE and PAYE require payments of 10% of discretionary income, with forgiveness after 20 years for undergraduate loans and 25 years for graduate loans. IBR varies between 10% and 15% based on when loans were taken, with forgiveness after 20 or 25 years, while ICR calculates payments as the lesser of 20% of discretionary income or a fixed 12-year repayment amount, with forgiveness after 25 years. Eligibility requires a verified FSA ID, recent income documentation, and annual recertification of income and family size; failure to recertify may increase payments and interest. Joint filers must include their spouse’s income unless separated, and only Direct Loans qualify unless others are consolidated. Private loans are ineligible, and borrowers in default must make satisfactory arrangements before enrolling.\"\n", - "user_instructions = [\n", - " \"Avoid overly technical or robotic phrasing; keep the tone human and accessible.\",\n", - " \"Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)\",\n", - " \"Response should not omit critical details needed to understand or answer the query\"\n", - "]" - ], - "metadata": { - "id": "Z4Qm_ME8nOKM" - }, - "execution_count": 25, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "#### 2. Call run_reprompting_pipeline()\n", - "\n", - "\n", - "Now that the configuration and test inputs are ready, we can pass it along with our LLM function to the pipeline. This will:\n", - "\n", - "* Send the input to your chosen LLM.\n", - "\n", - "* Use AIMon’s detectors to evaluate instruction adherence, groundedness, and toxicity.\n", - "\n", - "* Automatically generate corrective prompts and iterate up to max_iterations." - ], - "metadata": { - "id": "OKSFSglArHpw" - } - }, - { - "cell_type": "code", - "source": [ - "from aimon.reprompting_api.runner import run_reprompting_pipeline\n", - "\n", - "result = run_reprompting_pipeline(\n", - " llm_fn=my_llm,\n", - " user_query=user_query,\n", - " system_prompt= system_prompt,\n", - " context=context,\n", - " user_instructions=user_instructions,\n", - " reprompting_config=config\n", - " )" - ], - "metadata": { - "id": "p7GtwY9Cra0e" - }, - "execution_count": 26, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### Step 4: View your improved generated text and telemetry!" - ], - "metadata": { - "id": "w6xyeUFJrnho" - } - }, - { - "cell_type": "code", - "source": [ - "import json\n", - "\n", - "print(\"\\n=== SUMMARY ===\")\n", - "print(result.get(\"summary\"))\n", - "print(\"\\n=== BEST RESPONSE ===\")\n", - "print(result[\"best_response\"])\n", - "print(\"\\n=== TELEMETRY ===\")\n", - "print(json.dumps(result.get(\"telemetry\"), indent=2))" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AVke0epgru1d", - "outputId": "3efbdcc5-bbc0-42e3-b8a1-f4fa5a75e3a3" - }, - "execution_count": 27, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "=== SUMMARY ===\n", - "2 iterations, 0 failed instructions remaining\n", - "\n", - "=== BEST RESPONSE ===\n", - "Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\n", - "\n", - "Here's a breakdown based on the IDR options available:\n", - "\n", - "* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\n", - "* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\n", - "* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\n", - "\n", - "**To determine the specific forgiveness date for your loans, I need a little more information:**\n", - "\n", - "1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under.\n", - "\n", - "=== TELEMETRY ===\n", - "[\n", - " {\n", - " \"iteration\": 1,\n", - " \"cumulative_latency_ms\": 49848.28877449036,\n", - " \"scores\": {\n", - " \"groundedness\": 1.0,\n", - " \"instruction_adherence\": 0.6666666666666666,\n", - " \"toxicity\": 0.0\n", - " },\n", - " \"response_feedback\": [\n", - " {\n", - " \"type\": \"instruction_adherence_failure\",\n", - " \"source\": \"instruction_adherence\",\n", - " \"instruction\": \"Response should not omit critical details needed to understand or answer the query\",\n", - " \"score\": 0.4688,\n", - " \"explanation\": \"The response omits key details such as eligibility requirements and the need for annual recertification, leaving important information out.\"\n", - " }\n", - " ],\n", - " \"residual_error\": 0.08,\n", - " \"failed_instructions_count\": 1,\n", - " \"stop_reason\": \"instructions_failed_continue_reprompting\",\n", - " \"prompt_template\": \"System:\\n${system_prompt}\\n\\nContext:\\n${context}\\n\\nUser Query:\\n${user_query}\",\n", - " \"response_text\": \"Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under (\"\n", - " },\n", - " {\n", - " \"iteration\": 2,\n", - " \"cumulative_latency_ms\": 105391.15405082703,\n", - " \"scores\": {\n", - " \"groundedness\": 1.0,\n", - " \"instruction_adherence\": 1.0,\n", - " \"toxicity\": 0.0\n", - " },\n", - " \"response_feedback\": [],\n", - " \"residual_error\": 0.0,\n", - " \"failed_instructions_count\": 0,\n", - " \"stop_reason\": \"all_instructions_adhered\",\n", - " \"prompt_template\": \"Original system prompt:\\n${system_prompt}\\n\\nRevise your previous response to this query:\\n${user_query}\\n\\nContext:\\n${context}\\n\\nPrevious response:\\nOkay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under (\\n\\nAlmost there. Just a few small fixes needed.\\n\\nFix the following:\\n\\n1. We are 53.12% confident that the following instruction was not followed:\\n\\u2192 Violated Instruction: \\\"Response should not omit critical details needed to understand or answer the query\\\"\\n\\u2192 Explanation: The response omits key details such as eligibility requirements and the need for annual recertification, leaving important information out.\\n\\n\\nPreserve correct content. Return only the revised output with no extra explanation.\\nYou did well on these instructions. It is important that you continue to follow these instructions:\\n- Avoid overly technical or robotic phrasing; keep the tone human and accessible.\\n- Keep the tone professionally neutral by avoiding emotionally charged words, exclamations, or informal phrases (e.g., awesome, ugh, or emojis)\\n\",\n", - " \"response_text\": \"Okay, I can help you understand the potential forgiveness timeline for your graduate student loans under the Income-Driven Repayment (IDR) plans.\\n\\nHere's a breakdown based on the IDR options available:\\n\\n* **REPAYE and PAYE:** These plans require you to pay 10% of your discretionary income. Forgiveness is granted after **20 years** for undergraduate loans and **25 years** for graduate loans.\\n* **IBR (Income-Based Repayment):** Payments range from 10% to 15% of your discretionary income, depending on when your loans were taken out. Forgiveness is granted after **20 or 25 years**, depending on the loan origination date.\\n* **ICR (Income-Contingent Repayment):** Payments are calculated as the lesser of 20% of your discretionary income or a fixed 12-year repayment amount. Forgiveness is granted after **25 years**.\\n\\n**To determine the specific forgiveness date for your loans, I need a little more information:**\\n\\n1. **What are the origination dates of your graduate loans?** This is crucial because it determines which IBR repayment calculation you fall under.\"\n", - " }\n", - "]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "### Conclusion\n", - "\n", - "In this notebook, we demonstrated how to use AIMon’s Re‑prompting Pipeline to automatically improve LLM responses with targeted feedback. We covered:\n", - "\n", - "* Building a `my_llm` function to fill templated prompts and call any LLM.\n", - "\n", - "* Adjusting `RepromptingConfig` to control pipeline behavior.\n", - "\n", - "* Compiling test inputs, including `system_prompt`, `context`, `user_query`, and `user_instructions`.\n", - "\n", - "* Running the pipeline and reviewing the improved outputs.\n", - "\n", - "With these steps, you can integrate re‑prompting into your own workflows to make model outputs more accurate, consistent, and user‑aligned.\n", - "\n", - "For deeper insights into how re‑prompting improves instruction adherence across models and test cases, check out our blog post [link].\n", - "\n", - "To learn more about available configurations and advanced options, visit our documentation [link].\n", - "\n" - ], - "metadata": { - "id": "g7hpVaYWvkTQ" - } - } - ] -} \ No newline at end of file From 2f3d9f174231956e28fccb12ef7c751c06069b92 Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Thu, 31 Jul 2025 12:21:21 -0700 Subject: [PATCH 07/10] Resolving some of Preetam's comments by improving documentation / resolving typos --- aimon/reprompting_api/pipeline.py | 16 ++++++++++------ aimon/reprompting_api/runner.py | 20 +++++++------------- 2 files changed, 17 insertions(+), 19 deletions(-) diff --git a/aimon/reprompting_api/pipeline.py b/aimon/reprompting_api/pipeline.py index 13cd7f1..2635001 100644 --- a/aimon/reprompting_api/pipeline.py +++ b/aimon/reprompting_api/pipeline.py @@ -92,15 +92,18 @@ def run(self, system_prompt: str, context: str, user_query: str, user_instructio Process: 1. Build an initial prompt with query, context, and instructions. 2. Call the LLM to generate a response. - 3. Evaluate the response with AIMon detectors. + 3. Evaluate the response with AIMon detectors for instruction adherence, toxicity, and groundedness. + Toxicity and groundedness are always evaluated. If user_instructions are empty / not provided, the + instruction adherence detector is not used. 4. If violations are found, iteratively generate corrective prompts and re-prompt the LLM. - 5. Stop when all instructions are followed or iteration limits are reached. + 5. Stop when all instructions are followed and response has no hallucination or toxicity or when iteration or latency limits are reached. 6. Return the best response (lowest residual error) along with telemetry and a summary if configured. Args: - user_query (str): The user's query or instruction. - context (str): Contextual information to include in the prompt. - user_instructions (list[str]): Instructions the model must follow. + user_query (str): Must be a non-empty string. The user's query or instruction. + context (str): Contextual information to include in the prompt. May be an empty string, but it is recommended to be included. + user_instructions (list[str]): Instructions the model must follow. May be an empty list, but it is highly recommended to be included. + system_prompt (str): A high‑level role or behavior definition for the model. May be an empty string. Returns: dict: @@ -130,7 +133,7 @@ def run(self, system_prompt: str, context: str, user_query: str, user_instructio curr_result = self._detect_aimon_response(curr_payload, self.config.feedback_model_max_retries) logger.debug(f"AIMon evaluation result: {curr_result}") - # Get scores and detailed feedback on failured instructions + # Get scores and detailed feedback on failed instructions scores, feedback = self.get_response_feedback(curr_result) self._record_iteration_output(iteration_outputs, iteration_num, curr_generated_text, curr_result) @@ -158,6 +161,7 @@ def run(self, system_prompt: str, context: str, user_query: str, user_instructio curr_prompt = self._build_corrective_prompt(curr_payload, curr_result) # Retry LLM call with corrective prompt + curr_generated_text = self._call_llm(curr_prompt, self.config.user_model_max_retries) curr_generated_text = self._call_llm(curr_prompt,self.config.user_model_max_retries, system_prompt, context, user_query) # Re-evaluate the new response curr_payload = self._build_aimon_payload(context, user_query, user_instructions, curr_generated_text, system_prompt) diff --git a/aimon/reprompting_api/runner.py b/aimon/reprompting_api/runner.py index 0116cca..4bb072f 100644 --- a/aimon/reprompting_api/runner.py +++ b/aimon/reprompting_api/runner.py @@ -31,19 +31,13 @@ def run_reprompting_pipeline( and `"[no context provided]"`) to ensure template consistency. Args: - llm_fn (Callable[[Template, str, str, str], str]): - A function to call the LLM. Must accept a prompt template (recommended_prompt_template), - `system_prompt`, `context`, and `user_query`. - user_query (str): - The user’s query. Must be a non-empty string. - system_prompt (str, optional): - A system-level instruction string. Defaults to `"[no system prompt provided]"` if None or empty. - context (str, optional): - Supplemental context for the LLM. Defaults to `"[no context provided]"` if None or empty. - user_instructions (List[str], optional): - A list of instructions for the model to follow. Defaults to an empty list. - reprompting_config (RepromptingConfig, optional): - Configuration object for controlling pipeline behavior. + llm_fn (Callable[[Template, str, str, str], str]): A function to call the LLM. Must accept a prompt template (recommended_prompt_template), + `system_prompt`, `context`, and `user_query`. + user_query (str): The user’s query. Must be a non-empty string. + system_prompt (str, optional): A system-level instruction string. Defaults to `"[no system prompt provided]"` if None or empty. + context (str, optional): Supplemental context for the LLM. Defaults to `"[no context provided]"` if None or empty. + user_instructions (List[str], optional): A list of instructions for the model to follow. Defaults to an empty list. + reprompting_config (RepromptingConfig, optional): Configuration object for controlling pipeline behavior. Returns: dict: A structured dictionary containing: From a7f56e86f85fbe62370620adc0956ab265b3696d Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Thu, 31 Jul 2025 12:22:54 -0700 Subject: [PATCH 08/10] moving the tests into https://github.com/aimonlabs/aimon-python-sdk/tree/main/tests --- aimon/reprompting_api/tests/_init_.py | 0 {aimon/reprompting_api/tests => tests}/test_reprompting_cases.py | 0 .../reprompting_api/tests => tests}/test_reprompting_failures.py | 0 .../reprompting_api/tests => tests}/test_reprompting_success.py | 0 4 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 aimon/reprompting_api/tests/_init_.py rename {aimon/reprompting_api/tests => tests}/test_reprompting_cases.py (100%) rename {aimon/reprompting_api/tests => tests}/test_reprompting_failures.py (100%) rename {aimon/reprompting_api/tests => tests}/test_reprompting_success.py (100%) diff --git a/aimon/reprompting_api/tests/_init_.py b/aimon/reprompting_api/tests/_init_.py deleted file mode 100644 index e69de29..0000000 diff --git a/aimon/reprompting_api/tests/test_reprompting_cases.py b/tests/test_reprompting_cases.py similarity index 100% rename from aimon/reprompting_api/tests/test_reprompting_cases.py rename to tests/test_reprompting_cases.py diff --git a/aimon/reprompting_api/tests/test_reprompting_failures.py b/tests/test_reprompting_failures.py similarity index 100% rename from aimon/reprompting_api/tests/test_reprompting_failures.py rename to tests/test_reprompting_failures.py diff --git a/aimon/reprompting_api/tests/test_reprompting_success.py b/tests/test_reprompting_success.py similarity index 100% rename from aimon/reprompting_api/tests/test_reprompting_success.py rename to tests/test_reprompting_success.py From de5345c27a27bb9186ab455a5f00225868f0beff Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Thu, 31 Jul 2025 18:15:14 -0700 Subject: [PATCH 09/10] adding exponential backoff retry decorator to utils using the decorator to safely call the user-provided LLM function and the AIMon Detect function. Re-raises last encountered exception upon failure. Also handled 0 division error in get_penalized_average by returning -1 if the list of follow probabilities was empty and added this info to documentation --- aimon/reprompting_api/pipeline.py | 75 ++++++++++++++---------------- aimon/reprompting_api/utils.py | 64 +++++++++++++++++++++++-- tests/test_reprompting_failures.py | 9 ++-- 3 files changed, 101 insertions(+), 47 deletions(-) diff --git a/aimon/reprompting_api/pipeline.py b/aimon/reprompting_api/pipeline.py index 2635001..4e962f2 100644 --- a/aimon/reprompting_api/pipeline.py +++ b/aimon/reprompting_api/pipeline.py @@ -1,7 +1,7 @@ from aimon.reprompting_api.config import RepromptingConfig, StopReasons from aimon.reprompting_api.telemetry import TelemetryLogger from aimon.reprompting_api.reprompter import Reprompter -from aimon.reprompting_api.utils import toxicity_check, get_failed_instructions_count, get_failed_instructions, get_residual_error_score, get_failed_toxicity_instructions +from aimon.reprompting_api.utils import retry, toxicity_check, get_failed_instructions_count, get_failed_instructions, get_residual_error_score, get_failed_toxicity_instructions from aimon import Detect import time import random @@ -243,57 +243,50 @@ def _build_aimon_payload(self, context, user_query, user_instructions, generated } return payload - def _call_llm(self, prompt_template: Template, max_attempts, system_prompt=None, context=None, user_query=None, base_delay=1): + def _call_llm(self, prompt_template: Template, max_attempts, system_prompt=None, context=None, user_query=None): """ Calls the LLM with exponential backoff. Retries if the LLM call fails - OR returns a non-string value. Raises an exception if all retries fail. + OR returns a non-string value. If all retries fail, the last encountered + exception from the LLM call is re-raised. Args: prompt_template (Template): Prompt template for the LLM. max_attempts (int): Max retry attempts. - base_delay (float): Initial delay in seconds before backoff. - + Returns: str: LLM response text. Raises: - RuntimeError: If the LLM call fails or returns an invalid type after all retries. + RuntimeError: If the LLM call repeatedly fails, re-raises the last encountered error. + TypeError: If the LLM call fails to return a string. """ - last_exception = None - for attempt in range(max_attempts): - try: - logger.debug(f"LLM call attempt {attempt+1} with prompt template.") - result = self.llm_fn(prompt_template, system_prompt, context, user_query) - # Validate type - if not isinstance(result, str): - raise TypeError(f"LLM returned invalid type {type(result).__name__}, expected str.") - return result - except Exception as e: - last_exception = e - logger.warning(f"LLM call failed on attempt {attempt+1}: {e}") - wait_time = base_delay * (2 ** attempt) + random.uniform(0, 0.1) - time.sleep(wait_time) - raise RuntimeError(f"LLM call failed or returned invalid type after maximum retries. Last error: {last_exception}") + @retry(exception_to_check=Exception, tries=max_attempts, delay=1, backoff=2, logger=logger) + def backoff_call(): + result = self.llm_fn(prompt_template, system_prompt, context, user_query) + if not isinstance(result, str): + raise TypeError(f"LLM returned invalid type {type(result).__name__}, expected str.") + return result + return backoff_call() - def _detect_aimon_response(self, payload, max_attempts, base_delay=1): + def _detect_aimon_response(self, payload, max_attempts): """ Calls AIMon Detect with exponential backoff and returns the detection result. This method wraps the AIMon evaluation call, retrying if it fails due to transient errors (e.g., network issues or temporary service unavailability). It retries up to - `max_attempts` times with exponential backoff before raising a RuntimeError. + `max_attempts` times with exponential backoff before raising the last encountered + exception from the AIMon Detect call. Args: payload (dict): A dictionary containing 'context', 'user_query', 'instructions', and 'generated_text' for evaluation. max_attempts (int): Maximum number of retry attempts. - base_delay (float): Initial delay in seconds before exponential backoff. Returns: object: The AIMon detection result containing evaluation scores and feedback. Raises: - RuntimeError: If AIMon Detect fails after all retry attempts. + RuntimeError: If AIMon Detect fails after all retry attempts, re-raises the last encountered error. """ aimon_context = f"{payload['context']}\n\nUser Query:\n{payload['user_query']}" aimon_query = f"{payload['user_query']}\n\nInstructions:\n{payload['instructions']}" @@ -302,21 +295,23 @@ def _detect_aimon_response(self, payload, max_attempts, base_delay=1): def run_detection(query, instructions, generated_text, context): return query, instructions, generated_text, context - for attempt in range(max_attempts): - try: - logger.debug(f"AIMon detect attempt {attempt+1} with payload: {payload}") - _, _, _, _, result = run_detection( - aimon_query, - payload['instructions'], - payload['generated_text'], - aimon_context - ) - return result - except Exception as e: - logger.debug(f"AIMon detect failed on attempt {attempt+1}: {e}") - wait_time = base_delay * (2 ** attempt) + random.uniform(0, 0.1) - time.sleep(wait_time) - raise RuntimeError("AIMon detect call failed after maximum retries.") + @retry( + exception_to_check=Exception, + tries=max_attempts, + delay=1, + backoff=2, + logger=logger + ) + def inner_detection(): + logger.debug(f"AIMon detect call with payload: {payload}") + _, _, _, _, result = run_detection( + aimon_query, + payload['instructions'], + payload['generated_text'], + aimon_context + ) + return result + return inner_detection() def get_response_feedback(self, result): """ diff --git a/aimon/reprompting_api/utils.py b/aimon/reprompting_api/utils.py index e1144a8..20740fc 100644 --- a/aimon/reprompting_api/utils.py +++ b/aimon/reprompting_api/utils.py @@ -14,7 +14,62 @@ - Toxicity failures are flagged when follow_probability > TOXICITY_THRESHOLD (default 0.25). - Residual error scoring penalizes low follow probabilities more heavily and adds a flat penalty for any toxicity failures. """ -from typing import List +from typing import Callable, Type, Union, Tuple, Optional, List +from functools import wraps +import logging +import random +import time + +def retry( + exception_to_check: Union[Type[BaseException], Tuple[Type[BaseException], ...]], + tries: int = 5, + delay: int = 3, + backoff: int = 2, + logger: Optional[logging.Logger] = None, + log_level: int = logging.WARNING, + re_raise: bool = True, + jitter: float = 0.1 +) -> Callable: + """ + Retry calling the decorated function using an exponential backoff. + :param exception_to_check: Exception or a tuple of exceptions to check. + :param tries: Number of times to try (not retry) before giving up. + :param delay: Initial delay between retries in seconds. + :param backoff: Backoff multiplier e.g., a value of 2 will double the delay each retry. + :param logger: Logger to use. If None, print. + :param log_level: Logging level. + :param re_raise: Whether to re-raise the exception after the last retry. + :param jitter: The maximum jitter to apply to the delay as a fraction of the delay. + """ + + def deco_retry(func: Callable) -> Callable: + @wraps(func) + def f_retry(*args, **kwargs): + remaining_tries, current_delay = tries, delay + while remaining_tries > 1: + try: + return func(*args, **kwargs) + except exception_to_check as e: + msg = f"{e}, Retrying in {current_delay} seconds..." + if logger: + logger.log(log_level, msg) + else: + print(msg) + time.sleep(current_delay * (1 + jitter * (2 * random.random() - 1))) + remaining_tries -= 1 + current_delay *= backoff + try: + return func(*args, **kwargs) + except exception_to_check as e: + msg = f"Failed after {tries} tries. {e}" + if logger: + logger.log(log_level, msg) + else: + print(msg) + if re_raise: + raise + return f_retry + return deco_retry # toxicity threshold for AIMon detection; Follow probabilities above this are considered failures TOXICITY_THRESHOLD = 0.25 @@ -168,11 +223,14 @@ def penalized_average(probs: List[float]) -> float: Probabilities > 0.5 (passed instructions) recieve no penalty Args: - probs (List[float]): A list of follow probabilities. + probs (List[float]): A list of follow probabilities. Must be non-empty. Returns: - float: Penalized average. + float: Penalized average. Return -1 if probs is empty. """ + if not probs: # handle division by zero for empty list + return -1 + penalties = [] for p in probs: if p >= 0.5: diff --git a/tests/test_reprompting_failures.py b/tests/test_reprompting_failures.py index aacc764..acf9511 100644 --- a/tests/test_reprompting_failures.py +++ b/tests/test_reprompting_failures.py @@ -2,6 +2,7 @@ import pytest from string import Template from together import Together +import aimon from aimon.reprompting_api.config import RepromptingConfig from aimon.reprompting_api.runner import run_reprompting_pipeline @@ -61,7 +62,7 @@ def get_config_with_invalid_aimon_api_key(): def test_llm_failure(): """Should raise RuntimeError when the LLM function always fails.""" config = get_config() - with pytest.raises(RuntimeError, match="LLM call failed or returned invalid type after maximum retries."): + with pytest.raises(RuntimeError, match="LLM call failed intentionally for testing"): run_reprompting_pipeline( user_query="Test LLM failure handling", context="Context for failure test", @@ -85,9 +86,9 @@ def test_invalid_llm_fn(): @pytest.mark.integration def test_invalid_return_value(): - """Should raise RuntimeError when the LLM returns a non-string value.""" + """Should raise TypeError when the LLM returns a non-string value.""" config = get_config() - with pytest.raises(RuntimeError, match="LLM call failed or returned invalid type"): + with pytest.raises(TypeError, match="LLM returned invalid type int, expected str."): run_reprompting_pipeline( user_query="Test invalid return type", context="Context for type error", @@ -113,7 +114,7 @@ def test_empty_query(): def test_invalid_api_key(): """Should fail due to invalid AIMon API key.""" config = get_config_with_invalid_aimon_api_key() - with pytest.raises(RuntimeError): + with pytest.raises(aimon.AuthenticationError): run_reprompting_pipeline( user_query="Testing with invalid AIMon API key", context="Context for invalid key test", From cec997535d40f5863eb913644f13dbabf757384b Mon Sep 17 00:00:00 2001 From: ashah-aanya Date: Thu, 31 Jul 2025 18:45:51 -0700 Subject: [PATCH 10/10] removing TogetherAI integration in tests and using a dummy LLM response for pytest --- tests/test_reprompting_cases.py | 24 +------ tests/test_reprompting_failures.py | 20 +----- tests/test_reprompting_success.py | 105 ----------------------------- 3 files changed, 5 insertions(+), 144 deletions(-) delete mode 100644 tests/test_reprompting_success.py diff --git a/tests/test_reprompting_cases.py b/tests/test_reprompting_cases.py index 5dfa5ea..b913bf6 100644 --- a/tests/test_reprompting_cases.py +++ b/tests/test_reprompting_cases.py @@ -1,37 +1,23 @@ import os import pytest from string import Template -from together import Together from aimon.reprompting_api.config import RepromptingConfig from aimon.reprompting_api.runner import run_reprompting_pipeline -TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") AIMON_API_KEY = os.environ.get("AIMON_API_KEY") -client = Together(api_key=TOGETHER_API_KEY) - # --- Fixtures --- @pytest.fixture def my_llm(): """Mock LLM function for integration tests. Prints prompts and responses.""" def _my_llm(recommended_prompt_template: Template, system_prompt, context, user_query) -> str: - filled_prompt = recommended_prompt_template.substitute( + filled_prompt = recommended_prompt_template.safe_substitute( system_prompt=system_prompt or "", context=context or "", user_query=user_query or "" ) - print("\n==== LLM PROMPT SENT ====", flush=True) - print(filled_prompt, flush=True) - response = client.chat.completions.create( - model="mistralai/Mistral-7B-Instruct-v0.2", - messages=[{"role": "user", "content": filled_prompt}], - max_tokens=256, - temperature=0 - ) - print("\n==== LLM RAW RESPONSE ====", flush=True) - print(response.choices[0].message.content, flush=True) - return response.choices[0].message.content + return filled_prompt return _my_llm @pytest.fixture @@ -104,7 +90,6 @@ def print_result(test_name, result): # --- Tests --- -@pytest.mark.integration def test_low_latency_limit(my_llm, config_low_latency): """Test stopping behavior when latency limit is very low (100ms).""" result = run_reprompting_pipeline( @@ -117,7 +102,6 @@ def test_low_latency_limit(my_llm, config_low_latency): print_result("Low Latency Limit Test (100ms)", result) assert "best_response" in result -@pytest.mark.integration def test_latency_limit(my_llm, config_high_latency): """Test behavior with a high latency limit and contradictory instructions.""" result = run_reprompting_pipeline( @@ -130,7 +114,6 @@ def test_latency_limit(my_llm, config_high_latency): print_result("High Latency Limit Test (5000ms)", result) assert "best_response" in result -@pytest.mark.integration def test_iteration_limit(my_llm, config_iteration_limit): """Test behavior when max_iterations is 1.""" result = run_reprompting_pipeline( @@ -144,7 +127,6 @@ def test_iteration_limit(my_llm, config_iteration_limit): print_result("Iteration Limit Test (no re-prompting, only 1 iteration allowed)", result) assert "best_response" in result -@pytest.mark.integration def test_empty_context_and_instructions(my_llm, base_config): """Ensure pipeline works with no context, instructions, or system prompt.""" result = run_reprompting_pipeline( @@ -157,7 +139,6 @@ def test_empty_context_and_instructions(my_llm, base_config): print_result("Empty Context & Instructions Test", result) assert "best_response" in result -@pytest.mark.integration def test_no_telemetry(my_llm, config_without_telemetry): """Confirm telemetry and summary are excluded when disabled in config.""" result = run_reprompting_pipeline( @@ -171,7 +152,6 @@ def test_no_telemetry(my_llm, config_without_telemetry): assert "telemetry" not in result assert "summary" not in result -@pytest.mark.integration def test_no_system_prompt(my_llm, base_config): """Test behavior when system prompt is excluded.""" result = run_reprompting_pipeline( diff --git a/tests/test_reprompting_failures.py b/tests/test_reprompting_failures.py index acf9511..df5ca9b 100644 --- a/tests/test_reprompting_failures.py +++ b/tests/test_reprompting_failures.py @@ -1,30 +1,21 @@ import os import pytest from string import Template -from together import Together import aimon from aimon.reprompting_api.config import RepromptingConfig from aimon.reprompting_api.runner import run_reprompting_pipeline -TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") AIMON_API_KEY = os.environ.get("AIMON_API_KEY") -client = Together(api_key=TOGETHER_API_KEY) # --- MOCKED LLM FUNCTIONS --- def my_llm(prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: - """Simulates a normal working LLM that returns a string response.""" - filled_prompt = prompt_template.substitute( + """Simulates a normal working LLM that returns a string response. Just returns filled_prompt for test""" + filled_prompt = prompt_template.safe_substitute( system_prompt=system_prompt or "", context=context or "", user_query=user_query or "" ) - response = client.chat.completions.create( - model="mistralai/Mistral-7B-Instruct-v0.2", - messages=[{"role": "user", "content": filled_prompt}], - max_tokens=256, - temperature=0 - ) - return response.choices[0].message.content + return filled_prompt def llm_fn_failure(prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: """Simulates an LLM call that fails every time.""" @@ -58,7 +49,6 @@ def get_config_with_invalid_aimon_api_key(): ) # --- TESTS EXPECTING FAILURES --- -@pytest.mark.integration def test_llm_failure(): """Should raise RuntimeError when the LLM function always fails.""" config = get_config() @@ -71,7 +61,6 @@ def test_llm_failure(): user_instructions=[] ) -@pytest.mark.integration def test_invalid_llm_fn(): """Should raise TypeError when LLM function is None.""" config = get_config() @@ -84,7 +73,6 @@ def test_invalid_llm_fn(): user_instructions=[] ) -@pytest.mark.integration def test_invalid_return_value(): """Should raise TypeError when the LLM returns a non-string value.""" config = get_config() @@ -97,7 +85,6 @@ def test_invalid_return_value(): user_instructions=[] ) -@pytest.mark.integration def test_empty_query(): """Empty query should raise a ValueError.""" config = get_config() @@ -110,7 +97,6 @@ def test_empty_query(): user_instructions=[] ) -@pytest.mark.integration def test_invalid_api_key(): """Should fail due to invalid AIMon API key.""" config = get_config_with_invalid_aimon_api_key() diff --git a/tests/test_reprompting_success.py b/tests/test_reprompting_success.py deleted file mode 100644 index 5a6d2e6..0000000 --- a/tests/test_reprompting_success.py +++ /dev/null @@ -1,105 +0,0 @@ -import os -import logging -from string import Template -from together import Together -from aimon.reprompting_api.config import RepromptingConfig -from aimon.reprompting_api.runner import run_reprompting_pipeline - -# --- Configure logging --- -logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") -logger = logging.getLogger(__name__) - -# --- Load API keys --- -TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY") -AIMON_API_KEY = os.environ.get("AIMON_API_KEY") -if not TOGETHER_API_KEY or not AIMON_API_KEY: - logger.warning("API keys are missing. Make sure TOGETHER_API_KEY and AIMON_API_KEY are set.") - -# --- Initialize Together client --- -client = Together(api_key=TOGETHER_API_KEY) - -# --- LLM Function --- -def my_llm(recommended_prompt_template: Template, system_prompt=None, context=None, user_query=None) -> str: - """ - Example LLM function that: - 1. Receives a corrective prompt template (string.Template). - 2. Substitutes placeholders (system_prompt, context, user_query). - 3. Sends to a Together-hosted LLM and returns the response. - """ - filled_prompt = recommended_prompt_template.substitute( - system_prompt=system_prompt or "", - context=context or "", - user_query=user_query or "" - ) - logger.info(f"[LLM] Sending prompt to model: {filled_prompt[:200]}...") # Log preview - - response = client.chat.completions.create( - model="mistralai/Mistral-7B-Instruct-v0.2", - messages=[{"role": "user", "content": filled_prompt}], - max_tokens=256, - temperature=0 - ) - output = response.choices[0].message.content - logger.info(f"[LLM] Received response: {output[:200]}...") - return output - -# --- Test Case: Successful Run --- -def test_successful_run(): - """ - Simulates a realistic pipeline run with: - - Complex context - - Query for simplification - - Multiple style/tone instructions - - Telemetry & summary enabled - """ - logger.info("[Pipeline] Starting test run...") - - config = RepromptingConfig( - aimon_api_key=AIMON_API_KEY, - publish=True, - return_telemetry=True, - return_aimon_summary=True, - application_name="api_test", - max_iterations=3 - ) - logger.info("[Pipeline] Config prepared.") - - user_query = "What are the drug tiers?" - context = "[SECTION] 📘 BlueShield Rx Policy Addendum: 2023–2025 Commercial & Employer-Sponsored Plans [SECTION] Confidential – Not for external dissemination without compliance review. [SECTION] 🔹 Section 2.1.7 – Drug Coverage Eligibility Matrix [SECTION] Prescription drug eligibility is governed by a tiered, multi-variant benefit design informed by annual P&T Committee decisions, manufacturer rebates, CMS Part D benchmarking (when applicable), and employer-specific customizations. The following formulary tiers apply unless superseded by a group rider or conditional override: [SECTION] - **Tier 1 (Generic Core):** Includes FDA-approved AB-rated generics; requires no PA or ST, unless the member is flagged under the Risk Management Tier Hold (RMTH) protocol due to prior misuse. [SECTION] - **Tier 2 (Preferred Brand & Enhanced Generics):** Coverage dependent on documented trial/failure of Tier 1 alternatives unless contraindicated. Members in the Legacy Bridge plan must obtain both prescriber attestation and pharmacy alignment verification. [SECTION] - **Tier 3 (Non-Preferred & Specialty Entry):** May require dual-layer review if member has not met chronic condition enrollment criteria (CCE) in the last benefit year. Tier migration possible mid-cycle based on new formulary rules. [SECTION] - **Tier 4 (Specialty Injectables, Biologics, and Condition-Limited Agents):** Includes drugs subject to clinical pathway alignment; claims must be adjudicated through the PBM’s split-fulfillment logic unless the prescribing entity is credentialed as Tier 4-A. [SECTION] 🚫 Exception: Certain biosimilars classified under Tier 4 in national formularies may be covered at Tier 2 if dispensed under limited-distribution contracts, provided the prescribing facility participates in the 340B program **and** the member is flagged under Enhanced Affordability Priority (EAP). [SECTION] 🔁 **Prior Authorization (PA) Layering Logic** [SECTION] Drugs requiring PA are subject to a three-stage filter: [SECTION] 1. **Therapeutic Criteria Review (TCR)** – Clinical alignment with diagnosis and formulary path. [SECTION] 2. **Coverage Policy Sync (CPS)** – Matches requested use with plan sponsor coverage schema. [SECTION] 3. **Utilization Watch Flag (UWF)** – If triggered, a third-party medical director review is initiated (adds 2–4 business days). [SECTION] 💡 Exemplar: *Trulicity* (GLP-1 receptor agonist) [SECTION] - **Base Tier:** Tier 3 across most commercial plans [SECTION] - **Override Possibility:** Auto-lifts to Tier 2 under Metabolic Risk Bundling if member is concurrently enrolled in cardiac risk management AND insulin titration modules. [SECTION] - **Caveat:** Auto-injector version may still trigger UWF if prescribed without 90-day adherence documentation to metformin or contraindication to semaglutide. [SECTION] 🗂️ **Adjudication Complexity Notes** [SECTION] - Fill attempts at non-network or out-of-state pharmacies may default to full retail pricing, even if coverage is active. [SECTION] - Certain maintenance tier drugs can only be filled at 90-day intervals after two successful 30-day fills unless dispensed via SmartSync (auto-align refill system). [SECTION] - Claims using discount cards (e.g., manufacturer copay assistance) will not count toward deductible or out-of-pocket limits unless the pharmacy submits a Coordinated Adjudication Adjustment Request (CAAR). [SECTION] ⚠️ **Denials & Appeals** [SECTION] - If PA is denied, appeals must cite new clinical rationale. Re-submission of identical documentation will be auto-denied. [SECTION] - Members in Tier Restructuring Delay (TRD) periods due to employer override cannot file external appeals unless the drug is life-sustaining and not replaceable under Tier 1/2. [SECTION] - Denials on non-formulary drugs are not eligible for Tier Transition Program (TTP) unless covered during prior plan year with no lapse in coverage >30 days. [SECTION] 📊 **Plan Differences** [SECTION] - Standard, Enhanced, Platinum, and Concierge tiers each have different deductible-accumulation thresholds and copay structures. [SECTION] - For Platinum+ plans, Tier 3 copay is waived on first-time fills initiated post-discharge from an inpatient episode if coded using post-acute NDCs. [SECTION] 📣 Misc. Clarifications [SECTION] - The “Healthy Living Rewards” program, mentioned in new member packets, does not affect coverage or drug tier placement. It is a wellness initiative only. [SECTION] - Benefit year resets on Jan 1, but tier realignment occurs quarterly and may retroactively affect claims filled in the trailing 45-day buffer period. [SECTION] 🔒 REMINDER: Member Services guidance may reflect outdated tier assignments if formulary refreshes are in progress. Online lookup tools update in real time and take precedence during adjudication disputes." - system_prompt = "You are a knowledgeable but approachable healthcare benefits assistant. Your role is to help users understand BlueShield prescription drug policies by explaining terms and tiers in simple, clear, and user‑friendly language. Always prioritize accuracy and clarity over technical jargon." - user_instructions = [ - "Avoid overly technical or robotic phrasing; keep the tone human and accessible.", - "Ensure the response is direct and professional, with minimal informal tone.", - "Translate or simplify technical details from the context into accurate, user-friendly explanations." - ] - logger.info(f"[Pipeline] User query: {user_query}") - logger.info(f"[Pipeline] Context: {context[:100]}...") - logger.info(f"[Pipeline] Instructions: {user_instructions}") - - # Run pipeline - result = run_reprompting_pipeline( - llm_fn=my_llm, - user_query=user_query, - system_prompt= system_prompt, - context=context, - user_instructions=user_instructions, - reprompting_config=config - ) - - # Log each part of the result - logger.info("[Pipeline] Run complete.") - logger.info(f"[Pipeline] Best Response: {result['best_response']}") - logger.info(f"[Pipeline] Telemetry: {result.get('telemetry')}") - logger.info(f"[Pipeline] Summary: {result.get('summary')}") - - # Print outputs for inspection - print("\n=== BEST RESPONSE ===") - print(result["best_response"]) - print("\n=== TELEMETRY ===") - print(result.get("telemetry")) - print("\n=== SUMMARY ===") - print(result.get("summary")) - -# --- Entry Point --- -if __name__ == "__main__": - test_successful_run()