fabricatio 0.2.4.dev2__tar.gz → 0.2.4.dev3__tar.gz

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev2
+Version: 0.2.4.dev3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.4-dev2"
+version = "0.2.4-dev3"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/python/fabricatio/capabilities/rag.py

@@ -13,10 +13,16 @@ from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, ove
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.kwargs_types import CollectionSimpleConfigKwargs, EmbeddingKwargs, FetchKwargs, LLMKwargs
+from fabricatio.models.kwargs_types import (
+    ChooseKwargs,
+    CollectionSimpleConfigKwargs,
+    EmbeddingKwargs,
+    FetchKwargs,
+    LLMKwargs,
+)
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData
-from more_itertools.recipes import flatten
+from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
 
@@ -221,9 +227,9 @@ class RAG(EmbeddingUsage):
 
         # Step 2: Flatten the search results
         flattened_results = flatten(search_results)
-
+        unique_results = unique(flattened_results, key=itemgetter("id"))
         # Step 3: Sort by distance (descending)
-        sorted_results = sorted(flattened_results, key=itemgetter("distance"), reverse=True)
+        sorted_results = sorted(unique_results, key=itemgetter("distance"), reverse=True)
 
         logger.debug(f"Searched similarities: {[t['distance'] for t in sorted_results]}")
         # Step 4: Extract the entities
@@ -308,3 +314,21 @@ class RAG(EmbeddingUsage):
             f"{rendered}\n\n{extra_system_message}",
             **kwargs,
         )
+
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+        """Refines the given question using a template.
+
+        Args:
+            question (List[str] | str): The question to be refined.
+            **kwargs (Unpack[ChooseKwargs]): Additional keyword arguments for the refinement process.
+
+        Returns:
+            List[str]: A list of refined questions.
+        """
+        return await self.aliststr(
+            template_manager.render_template(
+                configs.templates.refined_query_template,
+                {"question": [question] if isinstance(question, str) else question},
+            ),
+            **kwargs,
+        )

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/python/fabricatio/config.py

@@ -209,6 +209,9 @@ class TemplateConfig(BaseModel):
     liststr_template: str = Field(default="liststr")
     """The name of the liststr template which will be used to display a list of strings."""
 
+    refined_query_template: str = Field(default="refined_query")
+    """The name of the refined query template which will be used to refine a query."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio-0.2.4.dev3/src/hbs_helpers.rs

@@ -0,0 +1,15 @@
+use handlebars::handlebars_helper;
+use serde_json::Value;
+
+handlebars_helper!(len: |v: Value| {
+    if v.is_array(){
+        v.as_array().unwrap().len()
+    }else if v.is_object(){
+        v.as_object().unwrap().len()
+    }else if v.is_string(){
+        v.as_str().unwrap().len()
+    }else{
+        0
+    }
+    
+});

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/src/lib.rs

@@ -1,5 +1,6 @@
 mod templates;
 mod hash;
+mod hbs_helpers;
 
 use pyo3::prelude::*;
 

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/src/templates.rs

@@ -1,3 +1,4 @@
+use crate::hbs_helpers::len;
 use handlebars::{no_escape, Handlebars};
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
@@ -34,6 +35,7 @@ impl TemplateManager {
             suffix:suffix.unwrap_or("hbs".to_string()) 
         };
         manager.discover_templates();
+        manager.register_builtin_helper();
         Ok(manager)
     }
 
@@ -90,6 +92,11 @@ impl TemplateManager {
             })
             .collect()
     }
+
+    fn register_builtin_helper(&mut self){
+        self.handlebars.register_helper("len",Box::new(len))
+    }
+
 }
 
 pub(crate) fn register(_: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {

fabricatio-0.2.4.dev3/templates/built-in/draft_rating_criteria.hbs

@@ -0,0 +1,40 @@
+# Task
+Please draft rating criteria for the topic: "{{ topic }}".
+
+## CFER Framework
+Create criteria that are:
+- **Comprehensive**: Cover all important aspects of the topic
+- **Fair**: Measurable and objective across different instances
+- **Evidence-based**: Can be evaluated based on observable evidence
+- **Relevant**: Directly related to the quality or performance of the topic
+
+Return the criteria{{#if criteria_count}} with exactly {{ criteria_count }} items{{/if}} in JSON format as a list of strings within code block.
+
+# Example:
+Rating criteria for the topic "Nice icecream"
+
+----- Start of response example -----
+```json
+[
+"Visual appeal (color, presentation, garnish)",
+"Flavor complexity and authenticity",
+"Texture consistency and mouthfeel",
+"Ingredient quality and freshness",
+"Value for price point"
+]
+```
+----- End of response example -----
+
+## Aspect Introduction
+Each criterion should:
+- Be concise yet descriptive (5-10 words)
+- Represent a distinct aspect of evaluation
+- Be applicable across different instances of the topic
+- Avoid overlapping with other criteria
+- Use terminology relevant to the domain
+
+# Warning
+- Please ensure that the criteria are clear, concise, and independently measurable.
+- The response SHALL be returned as a JSON array within the codeblock.
+- No additional explanation is needed.
+{{#if criteria_count }}- You must return exactly {{ criteria_count }} criteria.{{/if}}

{fabricatio-0.2.4.dev2 → fabricatio-0.2.4.dev3}/templates/built-in/draft_rating_manual.hbs

@@ -1,16 +1,22 @@
 # Task
-Please draft a rating manual for the following topic and criteria, which will be used to rate the entity based.
+Please draft a rating manual for the following topic and criteria. This manual will guide evaluators in applying consistent standards.
 
 Topic: {{ topic }}
 Criteria: {{ criteria }}
 
-Return the rating manual as a JSON object within the codeblock where the keys are the criteria and the values are the criteria for each criterion.
+## CFER Framework
+Ensure your rating manual follows these principles:
+- **Comprehensive**: Cover all important aspects of each criterion
+- **Fair**: Describe measurable and objective evaluation standards
+- **Evidence-based**: Focus on observable evidence for each rating level
+- **Relevant**: Connect directly to quality or performance within the topic
 
+Return the rating manual as a JSON object within a codeblock where the keys are the criteria and the values are the detailed descriptions for each criterion.
 
 # Example:
 
-topic: Nice icecream
-criteria:["outlook","taste","texture"]
+Topic: Nice icecream
+Criteria: ["outlook","taste","texture"]
 ----- Start of response example -----
 ```json
 {
@@ -19,9 +25,17 @@ criteria:["outlook","taste","texture"]
 "texture": "How the icecream feels. High score for smooth texture without icy bits, melts smoothly in the mouth providing a creamy experience; low score for rough texture containing many ice crystals, feeling like it has been frozen for too long lacking softness."
 }
 ```
------ end of response example -----
+----- End of response example -----
+
+## Aspect Introduction
+For each criterion in your manual:
+- Provide a clear definition of what the criterion measures
+- Include specific examples of high-quality and low-quality manifestations
+- Define observable characteristics evaluators should look for
+- Use domain-appropriate terminology
+- Ensure the description enables consistent application across different instances
 
 # Warning
 - Please ensure that the rating manual is clear and concise, and that the criteria for each criterion are well-defined.
 - The response SHALL be returned as a JSON object within the codeblock.
-- No additional Explanation is needed.
+- No additional explanation is needed.

fabricatio-0.2.4.dev3/templates/built-in/draft_rating_weights_klee.hbs

@@ -0,0 +1,44 @@
+# Task:
+Please compare the relative importance of the following criteria for evaluating "{{topic}}":
+
+First Criterion: {{first}}
+Second Criterion: {{second}}
+
+## CFER Framework
+When determining the relative importance weight, consider these principles:
+- **Comprehensive**: Consider how each criterion contributes to the overall evaluation
+- **Fair**: Base your weighting on objective measures rather than personal preference
+- **Evidence-based**: Consider measurable impacts of each criterion on outcomes
+- **Relevant**: Prioritize criteria based on their direct influence on {{topic}} quality
+
+Provide a positive floating-point number where:
+- 1.0 means the criteria are equally important
+- > 1.0 means `{{second}}` is more important (e.g., 2.0 means twice as important)
+- < 1.0 means `{{first}}` is more important (e.g., 0.5 means half as important)
+
+Your response SHALL be a positive floating-point number within a JSON codeblock.
+
+## Aspect Introduction
+When comparing these criteria:
+- Consider the core purpose and context of "{{topic}}"
+- Evaluate which criterion has broader impact on outcomes
+- Assess which criterion is more foundational or prerequisite
+- Consider which criterion is more difficult to compensate for if lacking
+- Think about which criterion users/stakeholders would prioritize
+- Consider industry standards and expert consensus in this domain
+
+# Example:
+Topic: "Best icecream"
+First Criterion: "Taste"
+Second Criterion: "Texture"
+
+----- Start of response example -----
+```json
+1.5
+```
+----- End of response example -----
+
+# Warning:
+- Your response must be a POSITIVE floating-point number within a JSON codeblock.
+- No explanation or additional information is needed, only the positive floating-point number.
+- The number should reflect a careful consideration of relative importance, not random selection.

fabricatio-0.2.4.dev3/templates/built-in/draft_tool_usage_code.hbs

@@ -0,0 +1,76 @@
+# Task: Draft Python Code for Tool Integration
+
+You are tasked with writing Python code that effectively utilizes specific tools to accomplish a defined task. This template will guide you to produce high-quality, executable code.
+
+## CFER Framework
+Your code solution should follow these principles:
+- **Comprehensive**: Utilize all relevant tools necessary to fully accomplish the task
+- **Functional**: Ensure the code executes without errors and handles edge cases appropriately
+- **Efficient**: Optimize for performance and resource utilization where appropriate
+- **Reliable**: Include proper error handling and validation for robust execution
+
+## Available Resources
+
+**Dependencies:**
+{{deps}}
+
+**Available Data:**
+{{#each data }}
+-------- Start of `{{ @key }}` --------
+{{ this }}
+-------- End of `{{ @key }}` --------
+{{/each }}
+
+**Task Briefing:**
+{{ task }}
+
+**Available Tools:**
+{{#each tools }}
+- `{{ name }}`
+{{/each }}
+
+## Implementation Guidelines
+When developing your solution:
+- Begin with proper tool imports and initialization
+- Structure your code with logical function organization
+- Implement appropriate error handling
+- Document key sections with clear comments
+- Define output variables to capture results
+- Follow Python best practices for code style
+
+## Response Format
+Provide your solution in the following format:
+
+1. Python code implementation in a code block
+2. JSON array of output variable names that contain your solution results
+
+## Example Response:
+
+---- Start of Response Example ----
+
+```python
+{{#if data}}# Import available data
+from {{data_module_name}} import ({{#each data }}{{@key}},{{/each }}){{/if}}
+# Import available tools
+from {{tool_module_name}} import ({{#each tools }}{{name}},{{/each }})
+
+output1 = # Create your output no.1 with `{{tool_module_name}}`{{#if data}} and `{{data_module_name}}`{{/if}} here, if needed
+another_output = # Create your output no.2 with `{{tool_module_name}}`{{#if data}} and `{{data_module_name}}`{{/if}} here, if needed
+yet_another_output = # Create your output no.3 with `{{tool_module_name}}`{{#if data}} and `{{data_module_name}}`{{/if}} ,here, if needed
+
+```
+
+```json
+[
+"output1",
+"another_output"
+"yet_another_output"
+]
+```
+---- End of Response Example ----
+
+## Constraints
+- Your solution must use ONLY the provided tools and data
+- Do not import any third-party libraries not specified in the dependencies
+- Ensure all output variables contain JSON-serializable values
+- Your response must include both the Python code block and the JSON output array code block

fabricatio-0.2.4.dev3/templates/built-in/extract_criteria_from_reasons.hbs

@@ -0,0 +1,49 @@
+# Task: Extract Evaluation Criteria from Reasons
+
+Extract {{criteria_count}} most important criteria for evaluating "{{topic}}" from the provided list of reasons. These criteria should capture the key aspects that matter most when comparing or evaluating items in this domain.
+
+## CFER Framework
+When extracting and refining criteria, follow these principles:
+- **Comprehensive**: Identify criteria that cover different aspects of the topic
+- **Focused**: Each criterion should represent a distinct evaluable dimension
+- **Extracted**: Derive criteria directly from the provided reasons, not external knowledge
+- **Refined**: Transform raw mentions into clear, concise evaluation dimensions
+
+## Input Reasons
+{{reasons}}
+
+## Extraction Guidelines
+When identifying criteria:
+1. Identify key comparison points mentioned across multiple reasons
+2. Look for qualities, features, or characteristics used to differentiate options
+3. Consider both explicitly stated and implicitly suggested evaluation factors
+4. Consolidate similar or related concepts into single meaningful criteria
+5. Prioritize criteria based on frequency of mention and importance to the topic
+6. Express each criterion as a single clear concept (usually a noun or noun phrase)
+
+## Response Format
+Return exactly {{criteria_count}} criteria as a JSON array of strings, ranked in DESCENDING order of importance.
+
+# Example:
+Topic: "Good icecream"
+Reasons: ["Vanilla Dream has a rich and authentic vanilla flavor, while Choco Delight has an artificial chocolate flavor.", "Vanilla Dream has a smooth and creamy texture, while Choco Delight has a rough texture with ice crystals.", "Choco Delight is more affordable than Vanilla Dream.", "Choco Delight has a wider variety of flavors compared to Vanilla Dream."]
+
+----- Start of response example -----
+```json
+[
+"flavor authenticity",
+"texture quality",
+"affordability",
+"flavor variety"
+]
+```
+----- End of response example -----
+
+## Format Requirements
+- Return EXACTLY {{criteria_count}} criteria, no more and no less
+- Format as a valid JSON array of strings
+- Each criterion should be concise (1-3 words when possible)
+- Use consistent terminology (prefer noun forms)
+- Ensure criteria are distinct from each other
+- List criteria in descending order of importance
+- No explanations or additional text outside the JSON array

fabricatio-0.2.4.dev3/templates/built-in/extract_reasons_from_examples.hbs

@@ -0,0 +1,48 @@
+# Task: Generate Comparative Reasons Between Examples
+
+Within the topic of "{{topic}}", analyze why "{{first}}" is better than "{{second}}" by providing {{reasons_count}} clear, substantiated reasons.
+
+## CFER Framework
+When formulating your comparative reasons:
+- **Comparative**: Each reason should directly contrast specific aspects of both examples
+- **Factual**: Base reasons on observable qualities rather than subjective opinions
+- **Explicit**: Clearly articulate the advantage that "{{first}}" has over "{{second}}"
+- **Relevant**: Focus on aspects that matter most within the context of "{{topic}}"
+
+## Reasoning Guidelines
+When developing your reasons:
+1. Identify specific features, attributes or characteristics where "{{first}}" excels
+2. For each feature, explain how it manifests in both examples with clear contrast
+3. Articulate why the difference matters in the context of "{{topic}}"
+4. Use concrete details rather than vague generalizations
+5. Ensure each reason addresses a distinct aspect (avoid overlap)
+6. Consider both qualitative and quantitative advantages where applicable
+
+## Response Format
+Provide exactly {{reasons_count}} reasons in a JSON array of strings. Each reason should:
+- Be a complete, self-contained statement
+- Include specific information about both "{{first}}" and "{{second}}"
+- Clearly explain the comparative advantage
+
+# Example:
+Topic: "Good icecream"
+First: "Vanilla Dream"
+Second: "Choco Delight"
+Reasons count: 2
+
+----- Start of response example -----
+```json
+[
+"Vanilla Dream has a rich and authentic vanilla flavor, while Choco Delight has an artificial chocolate flavor.",
+"Vanilla Dream has a smooth and creamy texture, while Choco Delight has a rough texture with ice crystals."
+]
+```
+----- End of response example -----
+
+## Format Requirements
+- Provide EXACTLY {{reasons_count}} reasons, no more and no less
+- Format as a valid JSON array of strings
+- Each reason should be a complete sentence with proper punctuation
+- Each reason must mention both "{{first}}" and "{{second}}" by name
+- Each reason should highlight a specific advantage of "{{first}}" over "{{second}}"
+- No explanations, justifications, or additional text outside the JSON array

fabricatio-0.2.4.dev3/templates/built-in/liststr.hbs

@@ -0,0 +1,44 @@
+# Task: Generate List of Strings
+
+{{requirement}}
+
+## CFER Framework
+When generating your list of strings, follow these principles:
+- **Complete**: Include all items that match the requirement criteria
+- **Focused**: Each string should represent a distinct, relevant item
+- **Exact**: Follow the requirement precisely without adding irrelevant items
+- **Refined**: Format each string consistently and appropriately
+
+## Response Guidelines
+When creating your list:
+1. Identify all items that fully satisfy the requirement
+2. Express each item as a clear, concise string
+3. Remove duplicates and redundant entries
+4. Use consistent formatting across all items (capitalization, terminology)
+5. Order items logically (alphabetical, chronological, or by importance)
+{{#if k}}6. Provide EXACTLY {{k}} items as specified{{/if}}
+
+## Response Format
+Return your list as a JSON array of strings within a code block.
+
+# Example:
+Requirement: Extract all fruit names mentioned in the text:
+"The apple is red, the banana is yellow, the orange is orange, and the green apple is sour."
+
+----- Start of response example -----
+```json
+[
+"apple",
+"banana",
+"orange",
+"green apple"
+]
+```
+----- End of response example -----
+
+## Format Requirements
+- Response MUST be a valid JSON array within a code block
+- Every element MUST be a string type
+- No explanations or additional text outside the code block
+- No empty strings or null values
+{{#if k}}- The array MUST contain EXACTLY {{k}} strings{{/if}}

fabricatio-0.2.4.dev3/templates/built-in/make_choice.hbs

@@ -0,0 +1,40 @@
+# Task: Make Selection from Available Options
+
+{{instruction}}
+
+## CFER Framework
+When selecting the most appropriate option(s), follow these principles:
+- **Considered**: Evaluate each option thoroughly against the requirements
+- **Focused**: Select only options that directly address the core needs
+- **Evidence-based**: Base your selection on concrete merits rather than assumptions
+- **Reasoned**: Prioritize options that best satisfy all critical requirements
+
+## Available Options
+{{#each options}}
+- **{{name}}**: {{briefing}}
+{{/each}}
+
+## Selection Guidelines
+When making your selection:
+1. Identify the key requirements in the instruction
+2. Evaluate how well each option satisfies these requirements
+3. Consider both primary functionality and secondary benefits
+4. Eliminate options that fail to meet essential criteria
+5. Prioritize options that offer the best overall solution
+{{#if k}}6. Select EXACTLY {{k}} options as specified{{/if}}
+
+## Response Format
+Return your selection as a JSON array of option names within a code block.
+
+# Example:
+----- Start of response example -----
+```json
+["option1", "option2"]
+```
+----- End of response example -----
+
+## Format Requirements
+- Response MUST be a valid JSON array containing only option names
+- Each selected option MUST be from the provided list: [{{#each options}}"{{name}}", {{/each}}]
+- No explanations or additional text outside the JSON code block
+{{#if k}}- The array MUST contain EXACTLY {{k}} options{{/if}}

fabricatio-0.2.4.dev3/templates/built-in/make_judgment.hbs

@@ -0,0 +1,35 @@
+# Task: Make Boolean Judgment
+
+{{ prompt }}
+
+## CFER Framework
+When making your judgment, follow these principles:
+- **Clear**: Assess the prompt against definitive criteria
+- **Focused**: Evaluate only what's directly requested, avoiding scope creep
+- **Evidence-based**: Base your judgment solely on the information provided
+- **Responsive**: Provide precisely the boolean value that answers the prompt
+
+## Judgment Guidelines
+When determining your response:
+1. Carefully analyze the exact wording of the prompt
+2. Identify the specific criteria that determine a true/false answer
+3. Apply logical reasoning without introducing external assumptions
+4. Make a definitive decision based on the available information
+{{#if affirm_case}}5. If {{affirm_case}}, respond `true`{{/if}}
+{{#if deny_case}}6. If {{deny_case}}, respond `false`{{/if}}
+
+## Response Format
+Return your judgment as a single boolean value (true or false) in a JSON code block.
+
+# Example:
+----- Start of response example -----
+```json
+true
+```
+----- End of response example -----
+
+## Format Requirements
+- Response MUST be EXACTLY `true` or `false` within a JSON code block
+- No explanations, qualifications, or additional text outside the code block
+- No "maybe," "it depends," or other non-boolean responses
+- No quotation marks around the boolean value in the JSON

fabricatio-0.2.4.dev3/templates/built-in/rate_fine_grind.hbs

@@ -0,0 +1,51 @@
+# Task: Rate Content on Multiple Dimensions
+
+Rate the following content based on the provided rating manual and score range:
+
+----- Start of content to rate -----
+{{ to_rate }}
+----- End of content to rate -----
+
+## CFER Framework
+When rating the content, follow these principles:
+- **Consistent**: Apply the same standards across all dimensions
+- **Factual**: Base ratings on observable qualities rather than subjective preferences
+- **Explicit**: Consider each dimension independently based on its defined criteria
+- **Refined**: Provide precise scores rounded to two decimal places
+
+## Rating Manual
+{{ rating_manual }}
+
+## Score Range
+- Minimum score: {{ min_score }}
+- Maximum score: {{ max_score }}
+
+## Rating Guidelines
+When determining your ratings:
+1. Analyze the content thoroughly against each dimension in the rating manual
+2. Consider only what's present in the content being rated
+3. Evaluate each dimension independently based on its specific criteria
+4. Assign precise scores within the specified range for each dimension
+5. Round all scores to exactly two decimal places
+6. Ensure no dimension is scored outside the range [{{ min_score }}, {{ max_score }}]
+
+## Response Format
+Return your ratings as a JSON object with dimension names as keys and scores as values.
+
+# Example:
+----- Start of response example -----
+```json
+{
+"outlook": 3.56,
+"taste": 4.55,
+"texture": 3.01
+}
+```
+----- End of response example -----
+
+## Format Requirements
+- Response MUST be a valid JSON object within a code block
+- Keys MUST match ALL dimensions from the rating manual: [{{#each rating_manual}}"{{@key}}",{{/each}}]
+- Values MUST be numeric, rounded to exactly two decimal places
+- All scores MUST be within the range [{{ min_score }}, {{ max_score }}]
+- No explanations or additional text outside the JSON code block

fabricatio-0.2.4.dev3/templates/built-in/refined_query.hbs

@@ -0,0 +1,36 @@
+{{#if question}}# Context
+You are a query refinement specialist optimizing search queries for vector database retrieval. Your goal is to improve how questions are framed to maximize relevant document retrieval.
+
+# Format
+For each query:
+- Make it more specific and focused
+- Add domain-specific terminology
+- Remove ambiguous language
+- Split complex questions into multiple simpler queries when appropriate
+- Each refined query should be 1-3 sentences
+
+# Aspects to Consider
+- Specificity: Replace vague terms with precise alternatives
+- Terminology: Include technical vocabulary relevant to the domain
+- Decomposition: Break down multi-part questions into separate queries
+- Context Enrichment: Add implied but unstated contextual elements
+- Information Density: Ensure key concepts are emphasized
+
+# Examples
+Original: "How do I implement authentication?"
+Refined:
+- "What are best practices for implementing user authentication in web applications?"
+- "How to securely store authentication credentials in a database?"
+
+Original: "Explain vector databases"
+Refined: "Technical explanation of vector database architecture and similarity search mechanisms for embedding storage"
+
+# Response
+Refine the following {{len question}} {{#if question.[1]}}queries{{else}}query{{/if}}:
+
+{{#each question}}
+- "{{this}}"
+{{/each}}
+
+Output ONLY the refined queries as a numbered list without explanations.
+{{/if}}