synkro 0.4.36__py3-none-any.whl

synkro/pipelines.py

@@ -0,0 +1,136 @@
+"""Pipeline creation utilities.
+
+Usage:
+    from synkro.pipelines import create_pipeline
+    from synkro.models.openai import OpenAI
+    from synkro.types import DatasetType
+
+    pipeline = create_pipeline(
+        model=OpenAI.GPT_5_MINI,
+        dataset_type=DatasetType.CONVERSATION,
+    )
+    dataset = pipeline.generate("policy text", traces=50)
+    
+    # Tool calling pipeline
+    from synkro import ToolDefinition
+    
+    web_search = ToolDefinition(
+        name="web_search",
+        description="Search the web",
+        parameters={"type": "object", "properties": {"query": {"type": "string"}}}
+    )
+    
+    pipeline = create_pipeline(
+        dataset_type=DatasetType.TOOL_CALL,
+        tools=[web_search],
+    )
+    dataset = pipeline.generate("Search guidelines", traces=50)
+"""
+
+from typing import TYPE_CHECKING
+
+from synkro.generation.generator import Generator
+from synkro.types import DatasetType
+from synkro.models import Model, OpenAI
+from synkro.reporting import ProgressReporter
+
+if TYPE_CHECKING:
+    from synkro.types.tool import ToolDefinition
+
+
+def create_pipeline(
+    model: Model = OpenAI.GPT_5_MINI,
+    dataset_type: DatasetType = DatasetType.CONVERSATION,
+    grading_model: Model = OpenAI.GPT_52,
+    max_iterations: int = 3,
+    skip_grading: bool = False,
+    reporter: ProgressReporter | None = None,
+    tools: list["ToolDefinition"] | None = None,
+    turns: int | str = "auto",
+    checkpoint_dir: str | None = None,
+    enable_hitl: bool = True,
+    base_url: str | None = None,
+    thinking: bool = False,
+    temperature: float = 0.7,
+) -> Generator:
+    """
+    Create a pipeline for generating training datasets.
+
+    Args:
+        model: Model enum for generation (default: OpenAI.GPT_5_MINI)
+        dataset_type: Type of dataset - CONVERSATION, INSTRUCTION, EVALUATION, or TOOL_CALL (default: CONVERSATION)
+        grading_model: Model enum for grading (default: OpenAI.GPT_52)
+        max_iterations: Max refinement iterations per trace (default: 3)
+        skip_grading: Skip grading phase for faster generation (default: False)
+        reporter: Progress reporter (default: RichReporter for console output)
+        tools: List of ToolDefinition for TOOL_CALL dataset type
+        turns: Conversation turns per trace. Use int for fixed turns, or "auto"
+            for policy complexity-driven turns (Simple=1-2, Conditional=3, Complex=5+)
+        checkpoint_dir: Directory for checkpoints. Enables resumable generation.
+        enable_hitl: Enable Human-in-the-Loop Logic Map editing (default: False)
+        base_url: Optional API base URL for local LLM providers (Ollama, vLLM, etc.)
+        thinking: Enable thinking mode with <think> tags in responses (default: False).
+            When enabled, assistant responses will include reasoning wrapped in
+            <think>...</think> tags, compatible with Qwen3 and DeepSeek-R1 formats.
+        temperature: Sampling temperature for generation (0.0-2.0, default: 0.7).
+            Lower values (0.1-0.3) produce more deterministic outputs for eval datasets.
+            Higher values (0.7-1.0) produce more diverse outputs for training data.
+
+    Returns:
+        Generator instance ready to use
+
+    Example:
+        >>> from synkro.pipelines import create_pipeline
+        >>> from synkro.models.openai import OpenAI
+        >>> from synkro.types import DatasetType
+        >>>
+        >>> pipeline = create_pipeline(
+        ...     model=OpenAI.GPT_5_MINI,
+        ...     dataset_type=DatasetType.CONVERSATION,
+        ... )
+        >>> dataset = pipeline.generate("policy text", traces=50)
+        >>> dataset.save("training.jsonl")
+
+        >>> # Multi-turn with fixed 3 turns
+        >>> pipeline = create_pipeline(turns=3)
+        >>> dataset = pipeline.generate("policy text", traces=50)
+
+        >>> # Silent mode for embedding
+        >>> from synkro.reporting import SilentReporter
+        >>> pipeline = create_pipeline(reporter=SilentReporter())
+
+        >>> # Interactive Logic Map editing
+        >>> pipeline = create_pipeline(enable_hitl=True)
+        >>> dataset = pipeline.generate("policy text", traces=50)
+
+        >>> # Tool calling dataset
+        >>> from synkro import ToolDefinition
+        >>> search_tool = ToolDefinition(
+        ...     name="web_search",
+        ...     description="Search the web for information",
+        ...     parameters={"type": "object", "properties": {"query": {"type": "string"}}}
+        ... )
+        >>> pipeline = create_pipeline(
+        ...     dataset_type=DatasetType.TOOL_CALL,
+        ...     tools=[search_tool],
+        ... )
+        >>> dataset = pipeline.generate("Search guidelines", traces=50)
+    """
+    return Generator(
+        dataset_type=dataset_type,
+        generation_model=model,
+        grading_model=grading_model,
+        max_iterations=max_iterations,
+        skip_grading=skip_grading,
+        reporter=reporter,
+        tools=tools,
+        turns=turns,
+        checkpoint_dir=checkpoint_dir,
+        enable_hitl=enable_hitl,
+        base_url=base_url,
+        thinking=thinking,
+        temperature=temperature,
+    )
+
+
+__all__ = ["create_pipeline"]

synkro/prompts/__init__.py

@@ -0,0 +1,57 @@
+"""Prompt templates and customizable prompt classes for Synkro."""
+
+from synkro.prompts.base import (
+    SystemPrompt,
+    ScenarioPrompt,
+    ResponsePrompt,
+    GradePrompt,
+    RefinePrompt,
+    PlanPrompt,
+)
+from synkro.prompts.templates import (
+    SYSTEM_PROMPT,
+    SCENARIO_GENERATOR_PROMPT,
+    CATEGORY_SCENARIO_PROMPT,
+    POLICY_PLANNING_PROMPT,
+    POLICY_COMPLEXITY_PROMPT,
+    BATCHED_RESPONSE_PROMPT,
+    BATCHED_GRADER_PROMPT,
+    BATCHED_REFINER_PROMPT,
+    SINGLE_RESPONSE_PROMPT,
+    SINGLE_GRADE_PROMPT,
+)
+from synkro.prompts.multiturn_templates import (
+    FOLLOW_UP_GENERATION_PROMPT,
+    MULTI_TURN_RESPONSE_PROMPT,
+    MULTI_TURN_INITIAL_PROMPT,
+    MULTI_TURN_GRADE_PROMPT,
+    MULTI_TURN_REFINE_PROMPT,
+)
+
+__all__ = [
+    # Prompt classes
+    "SystemPrompt",
+    "ScenarioPrompt",
+    "ResponsePrompt",
+    "GradePrompt",
+    "RefinePrompt",
+    "PlanPrompt",
+    # Raw templates
+    "SYSTEM_PROMPT",
+    "SCENARIO_GENERATOR_PROMPT",
+    "CATEGORY_SCENARIO_PROMPT",
+    "POLICY_PLANNING_PROMPT",
+    "POLICY_COMPLEXITY_PROMPT",
+    "BATCHED_RESPONSE_PROMPT",
+    "BATCHED_GRADER_PROMPT",
+    "BATCHED_REFINER_PROMPT",
+    "SINGLE_RESPONSE_PROMPT",
+    "SINGLE_GRADE_PROMPT",
+    # Multi-turn templates
+    "FOLLOW_UP_GENERATION_PROMPT",
+    "MULTI_TURN_RESPONSE_PROMPT",
+    "MULTI_TURN_INITIAL_PROMPT",
+    "MULTI_TURN_GRADE_PROMPT",
+    "MULTI_TURN_REFINE_PROMPT",
+]
+

synkro/prompts/base.py

@@ -0,0 +1,167 @@
+"""Customizable prompt classes for building your own generation pipelines."""
+
+from pydantic import BaseModel, Field
+from synkro.prompts.templates import (
+    SYSTEM_PROMPT,
+    SCENARIO_GENERATOR_PROMPT,
+    BATCHED_RESPONSE_PROMPT,
+    BATCHED_GRADER_PROMPT,
+    BATCHED_REFINER_PROMPT,
+    POLICY_PLANNING_PROMPT,
+)
+
+
+class SystemPrompt(BaseModel):
+    """The system prompt that defines the expert's role and behavior."""
+
+    template: str = Field(default=SYSTEM_PROMPT)
+
+    def render(self, **kwargs) -> str:
+        """Render the prompt with any custom variables."""
+        return self.template.format(**kwargs) if kwargs else self.template
+
+
+class ScenarioPrompt(BaseModel):
+    """Prompt for generating scenarios from policy documents."""
+
+    template: str = Field(default=SCENARIO_GENERATOR_PROMPT)
+
+    def render(self, policy: str, count: int, category: str | None = None) -> str:
+        """
+        Render the scenario generation prompt.
+
+        Args:
+            policy: The policy text
+            count: Number of scenarios to generate
+            category: Optional category to focus scenarios on
+        """
+        prompt = f"{self.template}\n\nPOLICY:\n{policy}\n\nGenerate exactly {count} scenarios."
+        if category:
+            prompt += f"\n\nFocus on scenarios related to: {category}"
+        return prompt
+
+
+class ResponsePrompt(BaseModel):
+    """Prompt for generating responses to scenarios."""
+
+    template: str = Field(default=BATCHED_RESPONSE_PROMPT)
+    system_prompt: str = Field(default=SYSTEM_PROMPT)
+
+    def render(self, scenarios: list[dict], policy: str) -> str:
+        """
+        Render the response generation prompt.
+
+        Args:
+            scenarios: List of scenario dicts with 'description' and 'context'
+            policy: The policy text for grounding responses
+        """
+        scenarios_text = "\n\n".join(
+            f"SCENARIO {i}:\n{s['description']}\n\nCONTEXT:\n{s['context']}"
+            for i, s in enumerate(scenarios)
+        )
+
+        return f"""{self.template}
+
+SYSTEM PROMPT TO USE:
+{self.system_prompt}
+
+POLICY:
+{policy}
+
+SCENARIOS:
+{scenarios_text}"""
+
+
+class GradePrompt(BaseModel):
+    """Prompt for grading response quality."""
+
+    template: str = Field(default=BATCHED_GRADER_PROMPT)
+
+    def render(self, responses: list[dict], policy: str) -> str:
+        """
+        Render the grading prompt.
+
+        Args:
+            responses: List of response dicts with messages
+            policy: The policy text to grade against
+        """
+        responses_text = "\n\n".join(
+            f"RESPONSE {i}:\n{r.get('assistant_message', r.get('messages', [{}])[-1].get('content', ''))}"
+            for i, r in enumerate(responses)
+        )
+
+        return f"""{self.template}
+
+POLICY:
+{policy}
+
+RESPONSES TO GRADE:
+{responses_text}"""
+
+
+class RefinePrompt(BaseModel):
+    """Prompt for refining failed responses."""
+
+    template: str = Field(default=BATCHED_REFINER_PROMPT)
+    system_prompt: str = Field(default=SYSTEM_PROMPT)
+
+    def render(self, failed_items: list[dict], policy: str) -> str:
+        """
+        Render the refinement prompt.
+
+        Args:
+            failed_items: List of dicts with 'scenario', 'response', and 'feedback'
+            policy: The policy text
+        """
+        items_text = "\n\n".join(
+            f"""SCENARIO {i}:
+{item['scenario']}
+
+ORIGINAL RESPONSE:
+{item['response']}
+
+GRADER FEEDBACK:
+- Policy Violations: {item.get('policy_violations', [])}
+- Missing Citations: {item.get('missing_citations', [])}
+- Incomplete Reasoning: {item.get('incomplete_reasoning', [])}
+- Vague Recommendations: {item.get('vague_recommendations', [])}
+- Summary: {item.get('feedback', '')}"""
+            for i, item in enumerate(failed_items)
+        )
+
+        return f"""{self.template}
+
+SYSTEM PROMPT TO USE:
+{self.system_prompt}
+
+POLICY:
+{policy}
+
+ITEMS TO REFINE:
+{items_text}"""
+
+
+class PlanPrompt(BaseModel):
+    """Prompt for planning generation categories."""
+
+    template: str = Field(default=POLICY_PLANNING_PROMPT)
+
+    def render(self, policy: str, target_traces: int) -> str:
+        """
+        Render the planning prompt.
+
+        Args:
+            policy: The policy text to analyze
+            target_traces: Target number of traces to generate
+        """
+        return f"""{self.template}
+
+POLICY/DOMAIN SPECIFICATION:
+{policy}
+
+TARGET TRACES: {target_traces}
+
+Respond with a JSON object containing:
+- "categories": array of category objects with "name", "description", and "traces"
+- "reasoning": explanation of your analysis and category choices"""
+