Structured Output Prompting

Java is a programming language created for platform-independent application development. It is commonly used for backend systems.

{
  "language": "Java",
  "type": "Programming language",
  "main_use": "Backend application development",
  "platform_independent": true
}

The candidate has five years of Java experience and strong Spring Boot knowledge. The candidate appears suitable for a senior backend developer role.

{
  "candidate_name": "Rahul Patil",
  "experience_years": 5,
  "primary_skill": "Java",
  "frameworks": ["Spring Boot", "Hibernate"],
  "recommended_role": "Senior Backend Developer",
  "suitable": true
}

Analyze the candidate information.
Return the result as one JSON object.
Include candidate_name as a string.
Include experience_years as an integer.
Include primary_skill as a string.
Include frameworks as an array of strings.
Include recommended_role as a string.
Include suitable as a boolean.
Do not include text before or after the JSON object.
Candidate information: Rahul has five years of Java experience and works with Spring Boot and Hibernate.

{
  "candidate_name": "Rahul",
  "experience_years": 5,
  "primary_skill": "Java",
  "frameworks": [
    "Spring Boot",
    "Hibernate"
  ],
  "recommended_role": "Senior Backend Developer",
  "suitable": true
}

"experience": 5

"years_of_experience": 5

"experience_years": 5

candidate["experience_years"]

{
  "product_name": "Laptop",
  "price": 65000,
  "available": true
}

customer_name

customerName

CustomerName

customer-name

info

product_description

value

monthly_revenue

result

eligibility_status

Extract invoice information.
Return invoice_number as the unique invoice identifier.
Return invoice_date as the date printed on the invoice.
Return supplier_name as the company that issued the invoice.
Return total_amount as the final amount after taxes.
Return currency as the three-letter currency code.

{
  "invoice_number": "INV-2026-1042",
  "invoice_date": "2026-08-06",
  "supplier_name": "ABC Technologies",
  "total_amount": 24500,
  "currency": "INR"
}

{
  "price": 1000,
  "product_price": 1000,
  "final_price": 1000
}

{
  "base_price": 1000,
  "discount_amount": 100,
  "final_price": 900
}

Return the result as a JSON object.
Include field_name as a data_type.
Use field_name to represent a clear meaning.
Do not rename the field.
Do not add undefined fields.

{
  "employee_name": "Amit"
}

Return employee_name as a string.

{
  "experience_years": 6
}

Return experience_years as an integer.
Do not include words such as years in the value.

{
  "experience_years": "6 years"
}

{
  "experience_years": 6
}

{
  "rating": 4.5
}

Return rating as a number between 0 and 5.

{
  "eligible": true
}

Return eligible as a boolean.
Use true or false only.
Do not use yes or no.

{
  "eligible": "Yes"
}

{
  "eligible": true
}

{
  "address": {
    "city": "Pune",
    "state": "Maharashtra",
    "country": "India"
  }
}

{
  "skills": [
    "Java",
    "Spring Boot",
    "MySQL"
  ]
}

{
  "middle_name": null
}

Analyze the employee record.
Return employee_name as a string.
Return age as an integer.
Return salary as a number.
Return permanent_employee as a boolean.
Return skills as an array of strings.
Return address as an object.
Return resignation_date as a string or null.
Do not convert numbers into strings.
Do not use yes or no for boolean values.

{
  "customer_id": "C1001",
  "customer_name": "Sneha",
  "email": "sneha@example.com"
}

{
  "customer_id": "C1001",
  "customer_name": "Sneha",
  "email": "sneha@example.com",
  "secondary_phone": null
}

Extract customer information.
customer_id is required.
customer_name is required.
email is required.
secondary_phone is optional.
company_name is optional.
Include all required fields in every response.
Use null for an optional field when the field is included but its value is unavailable.
Do not create information that is not present in the source.

{
  "customer_id": null,
  "customer_name": "Sneha",
  "email": "sneha@example.com"
}

{
  "success": false,
  "error_code": "MISSING_REQUIRED_FIELD",
  "missing_fields": [
    "customer_id"
  ]
}

{
  "employee_name": "Ravi",
  "address_city": "Pune",
  "address_state": "Maharashtra",
  "address_country": "India"
}

{
  "employee_name": "Ravi",
  "address": {
    "city": "Pune",
    "state": "Maharashtra",
    "country": "India"
  }
}

{
  "product_id": "P1001",
  "product_name": "Wireless Keyboard",
  "pricing": {
    "base_price": 1500,
    "discount": 200,
    "final_price": 1300,
    "currency": "INR"
  },
  "inventory": {
    "in_stock": true,
    "available_quantity": 24,
    "warehouse": "Pune"
  }
}

Analyze the product information.
Return product_id as a string.
Return product_name as a string.
Return pricing as an object.
Inside pricing, include base_price as a number.
Inside pricing, include discount as a number.
Inside pricing, include final_price as a number.
Inside pricing, include currency as a string.
Return inventory as an object.
Inside inventory, include in_stock as a boolean.
Inside inventory, include available_quantity as an integer.
Inside inventory, include warehouse as a string.
Do not move nested fields to the root object.
Do not add fields that are not defined.

{
  "company": {
    "department": {
      "team": {
        "team_lead": "Anita"
      }
    }
  }
}

{
  "skills": [
    "Java",
    "Spring Boot",
    "Docker"
  ]
}

{
  "monthly_sales": [
    45000,
    52000,
    61000
  ]
}

{
  "employees": [
    {
      "employee_id": "E101",
      "employee_name": "Ajay"
    },
    {
      "employee_id": "E102",
      "employee_name": "Pooja"
    }
  ]
}

Return the skills.

Return skills as an array of strings.
Include one skill per array item.
Do not combine multiple skills in one string.

{
  "skills": [
    "Java, Spring Boot, MySQL"
  ]
}

{
  "skills": [
    "Java",
    "Spring Boot",
    "MySQL"
  ]
}

Return key_points as an array of strings.
Include at least three items.
Include no more than five items.
Keep every item under twenty words.

{
  "certifications": []
}

{
  "certifications": null
}

{
  "certifications": []
}

Return technologies as an array of unique strings.
Do not include duplicate technology names.

Sort skills alphabetically.
Sort transactions by transaction_date in ascending order.
Order recommendations from highest priority to lowest priority.

Extract all projects from the resume.
Return projects as an array of objects.
Each project object must contain project_name as a string.
Each project object must contain role as a string.
Each project object must contain technologies as an array of strings.
Each project object must contain duration_months as an integer or null.
Return an empty array when no projects are found.
Do not invent missing projects.
Do not include duplicate projects.

{
  "priority": "high"
}

Classify the support ticket.
Return priority as one of low, medium, high, or critical.
Return category as one of billing, technical, account, or general.
Return status as one of open, pending, resolved, or closed.
Do not return values outside the allowed lists.

{
  "priority": "high",
  "category": "technical",
  "status": "open"
}

Return severity as one of low, medium, high, or critical.
Use low when the issue has little impact.
Use medium when the issue affects one user but has a workaround.
Use high when the issue affects multiple users or blocks an important task.
Use critical when the complete system is unavailable or data is at risk.

{
  "termination_date": null
}

{
  "employee_name": "Anil"
}

{
  "middle_name": "N/A"
}

{
  "middle_name": null
}

"type": [
  "string",
  "null"
]

Extract the employee details.
Return employee_id as a string.
Return employee_name as a string.
Return middle_name as a string or null.
Return resignation_date as a string or null.
Use null when the source does not provide the value.
Do not use N/A, unknown, none, or an empty string.
Do not invent missing values.

{
  "middle_name": ""
}

{
  "middle_name": null
}

{
  "certifications": []
}

{
  "candidate_name": "Meera Joshi",
  "experience_years": 4,
  "recommendation": "hire",
  "skills": [
    "Java",
    "Spring Boot"
  ]
}

{
  "candidate_name": "Meera Joshi",
  "experience_years": "four",
  "recommendation": "hire",
  "skills": [
    "Java",
    "Spring Boot"
  ]
}

{
  "candidate_name": "Meera Joshi",
  "experience_years": 4,
  "recommendation": "strongly recommended",
  "skills": [
    "Java",
    "Spring Boot"
  ]
}

{
  "candidate_name": "Meera Joshi",
  "skills": [
    "Java",
    "Spring Boot"
  ]
}

{
  "age": "thirty"
}

Return only valid JSON.
Follow the exact field names.
Follow the defined data types.
Include all required fields.
Use only allowed enum values.
Do not add undefined fields.
Validate the response against the schema before returning it.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "age": {
      "type": "integer"
    }
  },
  "required": [
    "name",
    "age"
  ]
}

{
  "type": "string"
}

{
  "type": "object",
  "properties": {
    "product_name": {
      "type": "string"
    },
    "price": {
      "type": "number"
    }
  }
}

{
  "required": [
    "product_name",
    "price"
  ]
}

{
  "additionalProperties": false
}

{
  "type": "string",
  "enum": [
    "low",
    "medium",
    "high"
  ]
}

{
  "type": "integer",
  "minimum": 0,
  "maximum": 100
}

{
  "type": "string",
  "minLength": 2,
  "maxLength": 100
}

{
  "type": "string",
  "format": "email"
}

{
  "type": "string",
  "pattern": "^[A-Z]{3}-[0-9]{4}$"
}

ABC-1024

{
  "type": "array",
  "items": {
    "type": "string"
  }
}

{
  "type": "array",
  "minItems": 1,
  "maxItems": 5
}

{
  "type": "array",
  "uniqueItems": true
}

{
  "type": "object",
  "properties": {
    "employee_name": {
      "type": "string"
    },
    "address": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "city",
        "state"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "employee_name",
    "address"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "candidate_name": {
      "type": "string",
      "minLength": 1
    },
    "experience_years": {
      "type": "integer",
      "minimum": 0
    },
    "skills": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "uniqueItems": true
    },
    "recommendation": {
      "type": "string",
      "enum": [
        "hire",
        "reject",
        "review"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "candidate_name",
    "experience_years",
    "skills",
    "recommendation",
    "summary"
  ],
  "additionalProperties": false
}

Analyze the candidate profile.
Return one JSON object that follows the provided JSON Schema.
Use the exact property names from the schema.
Include every required property.
Do not include additional properties.
Use null only where the schema allows null.
Use only values allowed by enum.
Return only the JSON object.
Validate the object before returning it.

{
  "name": "string",
  "age": "integer",
  "status": "active or inactive"
}

{
  "name": "Kiran",
  "age": 29
}

{
  "name": "Kiran",
  "age": "29",
  "status": "active"
}

{
  "name": "Kiran",
  "age": 29,
  "status": "working"
}

{
  "name": "Kiran",
  "age": 29,
  "status": "active",
  "department": "Development"
}

{
  "success": false,
  "error_code": "SCHEMA_VALIDATION_FAILED",
  "message": "The generated response did not match the required schema.",
  "validation_errors": [
    {
      "field": "age",
      "issue": "Expected integer but received string"
    }
  ]
}

The previous response failed schema validation.
Correct only the reported validation errors.
Keep all valid values unchanged.
Include every required field.
Remove all undefined fields.
Follow the exact data types.
Return only the corrected JSON object.
Validation errors: age must be an integer.
Previous response: {"name":"Kiran","age":"29","status":"active"}

{
  "name": "Kiran",
  "age": 29,
  "status": "active"
}

Try again.

The previous response is invalid.
The experience_years field must be an integer.
The recommendation field must be hire, reject, or review.
Remove the extra confidence_text field.
Return only the corrected JSON object.
Do not change valid fields.

Correct the previous structured response.
Follow the original schema exactly.
Fix every listed validation error.
Keep valid field values unchanged.
Do not add explanations.
Do not include markdown formatting.
Return only one valid JSON object.
Validation errors: {validation_errors}
Previous response: {previous_response}

Original task: Extract invoice details.
Validation error: total_amount must be a number.
Previous response: {"invoice_number":"INV-101","total_amount":"₹5,000"}
Correction rule: Remove currency symbols from numeric fields.
Return only corrected JSON.

{
  "invoice_number": "INV-101",
  "total_amount": 5000
}

Modify only fields that failed validation.
Keep all other field values unchanged.

{
  "success": false,
  "error_code": "STRUCTURED_OUTPUT_GENERATION_FAILED",
  "message": "A valid structured response could not be generated.",
  "retry_count": 2
}

Analyze the customer review.
Return one JSON object.
Include sentiment as one of positive, negative, neutral, or mixed.
Include confidence as a number between 0 and 1.
Include key_reasons as an array of strings.
Include requires_follow_up as a boolean.
Return only JSON.
Review: The product quality is excellent, but delivery was delayed by six days.

{
  "sentiment": "mixed",
  "confidence": 0.94,
  "key_reasons": [
    "The customer praised the product quality.",
    "The customer reported a six-day delivery delay."
  ],
  "requires_follow_up": true
}

Extract candidate information from the resume text.
Return candidate_name as a string or null.
Return email as a string or null.
Return phone as a string or null.
Return total_experience_years as a number or null.
Return primary_role as a string or null.
Return technical_skills as an array of unique strings.
Return education as an array of objects.
Each education object must contain degree as a string or null.
Each education object must contain institution as a string or null.
Each education object must contain completion_year as an integer or null.
Use null when a single value is unavailable.
Use an empty array when no list items are found.
Do not invent missing information.
Return only JSON.

{
  "candidate_name": "Arjun Deshmukh",
  "email": "arjun@example.com",
  "phone": null,
  "total_experience_years": 4.5,
  "primary_role": "Java Developer",
  "technical_skills": [
    "Java",
    "Spring Boot",
    "Hibernate",
    "MySQL"
  ],
  "education": [
    {
      "degree": "Bachelor of Engineering",
      "institution": "Pune University",
      "completion_year": 2021
    }
  ]
}

Analyze the support ticket.
Return ticket_category as one of billing, technical, account, delivery, or general.
Return priority as one of low, medium, high, or critical.
Return summary as a string under thirty words.
Return detected_products as an array of strings.
Return requires_human_agent as a boolean.
Return suggested_action as a string.
Return only one JSON object.
Ticket: I cannot log in after changing my password. The reset link also shows an expired token message.

{
  "ticket_category": "account",
  "priority": "high",
  "summary": "The customer cannot access the account because the password reset link returns an expired token error.",
  "detected_products": [],
  "requires_human_agent": true,
  "suggested_action": "Verify the account and issue a new secure password reset link."
}

Compare the two products.
Return products as an array of objects.
Each product object must contain name as a string.
Each product object must contain price as a number.
Each product object must contain advantages as an array of strings.
Each product object must contain disadvantages as an array of strings.
Return recommended_product as a string.
Return recommendation_reason as a string.
Return only JSON.
Product A costs 50000 and has better battery life.
Product B costs 45000 and has better display quality.

{
  "products": [
    {
      "name": "Product A",
      "price": 50000,
      "advantages": [
        "Better battery life"
      ],
      "disadvantages": [
        "Higher price"
      ]
    },
    {
      "name": "Product B",
      "price": 45000,
      "advantages": [
        "Better display quality",
        "Lower price"
      ],
      "disadvantages": [
        "Lower battery performance than Product A"
      ]
    }
  ],
  "recommended_product": "Product B",
  "recommendation_reason": "Product B provides a lower price and better display quality, making it suitable for users who value screen quality and cost."
}

Review the Java method.
Return language as the string Java.
Return valid_code as a boolean.
Return issue_count as an integer.
Return issues as an array of objects.
Each issue object must contain line_number as an integer or null.
Each issue object must contain severity as one of low, medium, high, or critical.
Each issue object must contain category as one of syntax, logic, security, performance, readability, or maintainability.
Each issue object must contain description as a string.
Each issue object must contain suggested_fix as a string.
Return corrected_code as a string or null.
Return only JSON.
Java code: public int divide(int a, int b) { return a / b; }

{
  "language": "Java",
  "valid_code": true,
  "issue_count": 1,
  "issues": [
    {
      "line_number": 1,
      "severity": "high",
      "category": "logic",
      "description": "The method does not handle division by zero.",
      "suggested_fix": "Check whether b is zero before performing division."
    }
  ],
  "corrected_code": "public int divide(int a, int b) { if (b == 0) { throw new IllegalArgumentException(\"Divisor cannot be zero\"); } return a / b; }"
}

Extract invoice data.
Return invoice_number as a string or null.
Return invoice_date as a date string in YYYY-MM-DD format or null.
Return supplier as an object.
Inside supplier, include name as a string or null.
Inside supplier, include tax_id as a string or null.
Return items as an array of objects.
Each item must contain description as a string.
Each item must contain quantity as a number.
Each item must contain unit_price as a number.
Each item must contain line_total as a number.
Return subtotal as a number or null.
Return tax_amount as a number or null.
Return total_amount as a number or null.
Return currency as a three-letter currency code or null.
Do not include currency symbols in number fields.
Do not calculate missing values unless explicitly instructed.
Return only JSON.

{
  "invoice_number": "INV-2026-4401",
  "invoice_date": "2026-08-06",
  "supplier": {
    "name": "CodeTech Services",
    "tax_id": "27ABCDE1234F1Z5"
  },
  "items": [
    {
      "description": "Website Development",
      "quantity": 1,
      "unit_price": 30000,
      "line_total": 30000
    }
  ],
  "subtotal": 30000,
  "tax_amount": 5400,
  "total_amount": 35400,
  "currency": "INR"
}

Generate metadata for the article.
Return title as a string between forty and sixty characters.
Return meta_description as a string under one hundred sixty characters.
Return slug as a lowercase hyphen-separated string.
Return primary_keyword as a string.
Return secondary_keywords as an array of five unique strings.
Return category as one of prompt-engineering, artificial-intelligence, programming, or career.
Return reading_time_minutes as an integer.
Return only JSON.
Article topic: Structured Output Prompting for beginners.

{
  "title": "Structured Output Prompting: Complete Beginner Guide",
  "meta_description": "Learn structured output prompting, JSON schemas, validation, required fields, nested objects, arrays, and reliable AI response design.",
  "slug": "structured-output-prompting-beginner-guide",
  "primary_keyword": "structured output prompting",
  "secondary_keywords": [
    "JSON output prompting",
    "schema-based prompting",
    "structured AI responses",
    "JSON Schema",
    "prompt validation"
  ],
  "category": "prompt-engineering",
  "reading_time_minutes": 12
}

Role: You are a data extraction assistant.
Task: Analyze the provided input and return structured data.
Output format: Return one valid JSON object.
Field rule: Use only the field names defined below.
Type rule: Follow the specified data type for every field.
Required rule: Include every required field.
Optional rule: Include optional fields only according to the defined missing-value policy.
Null rule: Use null only for fields that explicitly allow null.
Array rule: Use an empty array when no list items are found.
Enum rule: Use only values from the allowed enum lists.
Nested object rule: Keep nested fields inside their defined parent object.
Additional field rule: Do not add undefined fields.
Accuracy rule: Do not invent missing information.
Validation rule: Validate the response against the schema before returning it.
Response rule: Do not include explanations, headings, markdown, or text outside the JSON object.
Schema: {insert_schema_here}
Input: {insert_input_here}

Analyze the customer request.
Return customer_name as a string or null.
Return request_type as one of complaint, question, refund, cancellation, or feedback.
Return priority as one of low, medium, high, or critical.
Return products as an array of strings.
Return problem_summary as a string under fifty words.
Return requested_resolution as a string or null.
Return requires_human_support as a boolean.
Use null when a single value is unavailable.
Use an empty array when no products are mentioned.
Do not invent names, products, or requested actions.
Do not add fields.
Return only one valid JSON object.
Customer request: {insert_customer_request_here}

Analyze the provided text.
Generate output that follows the JSON Schema exactly.
Use exact field names.
Include all required fields.
Follow all field data types.
Follow all enum restrictions.
Follow all minimum and maximum limits.
Do not add undefined fields.
Use null only where allowed.
Return only one valid JSON object.
JSON Schema:
{
  "type": "object",
  "properties": {
    "category": {
      "type": "string",
      "enum": [
        "technical",
        "billing",
        "account",
        "general"
      ]
    },
    "priority": {
      "type": "string",
      "enum": [
        "low",
        "medium",
        "high",
        "critical"
      ]
    },
    "summary": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200
    },
    "requires_follow_up": {
      "type": "boolean"
    }
  },
  "required": [
    "category",
    "priority",
    "summary",
    "requires_follow_up"
  ],
  "additionalProperties": false
}
Input: {insert_input_here}

// Validate the structured candidate response
function validateCandidate(data) {
  const errors = [];
  if (typeof data !== "object" || data === null || Array.isArray(data)) {
    errors.push("Response must be an object.");
    return errors;
  }
  if (typeof data.candidate_name !== "string" || data.candidate_name.trim() === "") {
    errors.push("candidate_name must be a non-empty string.");
  }
  if (!Number.isInteger(data.experience_years) || data.experience_years < 0) {
    errors.push("experience_years must be a non-negative integer.");
  }
  const allowedRecommendations = ["hire", "reject", "review"];
  if (!allowedRecommendations.includes(data.recommendation)) {
    errors.push("recommendation must be hire, reject, or review.");
  }
  if (!Array.isArray(data.skills) || !data.skills.every(skill => typeof skill === "string")) {
    errors.push("skills must be an array of strings.");
  }
  return errors;
}
// Test the response
const candidate = {
  candidate_name: "Neha",
  experience_years: 5,
  recommendation: "hire",
  skills: ["Java", "Spring Boot"]
};
const validationErrors = validateCandidate(candidate);
console.log(validationErrors.length === 0 ? "Valid response" : validationErrors);

# Validate a structured employee response
def validate_employee(data):
    errors = []
    if not isinstance(data, dict):
        return ["Response must be an object."]
    if not isinstance(data.get("employee_id"), str) or not data.get("employee_id"):
        errors.append("employee_id must be a non-empty string.")
    if not isinstance(data.get("age"), int) or data.get("age") < 18:
        errors.append("age must be an integer greater than or equal to 18.")
    if data.get("status") not in ["active", "inactive"]:
        errors.append("status must be active or inactive.")
    if not isinstance(data.get("skills"), list):
        errors.append("skills must be an array.")
    elif not all(isinstance(skill, str) for skill in data["skills"]):
        errors.append("Every skill must be a string.")
    return errors
# Test the structured response
employee = {
    "employee_id": "E1001",
    "age": 28,
    "status": "active",
    "skills": ["Java", "SQL"]
}
validation_errors = validate_employee(employee)
print("Valid response" if not validation_errors else validation_errors)

// Validate a structured product object
public class ProductValidator {
    public static boolean isValidProduct(Product product) {
        if (product == null) {
            return false;
        }
        if (product.getProductName() == null || product.getProductName().isBlank()) {
            return false;
        }
        if (product.getPrice() < 0) {
            return false;
        }
        if (product.getCategory() == null) {
            return false;
        }
        return true;
    }
}

// Represent structured product data
public class Product {
    private String productName;
    private double price;
    private String category;
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getCategory() {
        return category;
    }
    public void setCategory(String category) {
        this.category = category;
    }
}

Return the answer in JSON.

Return one JSON object.
Include topic as a string.
Include summary as a string.
Include key_points as an array of strings.

{
  "price": "5000 INR"
}

{
  "price": 5000,
  "currency": "INR"
}

{
  "priority": "very urgent"
}

{
  "priority": "critical"
}

Here is the requested JSON:
{
  "status": "success"
}

{
  "status": "success"
}

{
  "phone": ""
}

{
  "phone": null
}

{
  "skills": {
    "first": "Java",
    "second": "Python"
  }
}

{
  "skills": [
    "Java",
    "Python"
  ]
}

experience_years

years_of_experience

{
  "name": "Rohit",
  "age": 30,
  "status": "active",
  "description": "Experienced employee"
}

{
  "weight": 75,
  "weight_unit": "kg"
}

{
  "weight": "75 kg"
}

Always include every field.
Omit fields when values are unavailable.

Do not invent values that are not supported by the input.

Role: You are a structured data generation assistant.
Objective: Convert the provided input into a validated structured response.
Output format: Return one valid JSON object.
Field names: Use the exact field names defined in the schema.
Data types: Follow the required data type for every field.
Required fields: Include every property listed as required.
Optional fields: Follow the defined rule for unavailable optional values.
Missing values: Use null only when the schema allows null.
Empty collections: Use an empty array when no valid list items are found.
Enumerations: Use only values listed in enum definitions.
Nested objects: Keep child fields inside their defined parent object.
Arrays: Follow the defined item structure and length rules.
Number rules: Follow all minimum and maximum limits.
String rules: Follow all length, pattern, and format rules.
Extra properties: Do not add properties that are not defined.
Accuracy: Use only information supported by the provided input.
Validation: Check the complete response against the schema before returning it.
Correction: Fix all schema violations before producing the final response.
Response restriction: Do not include headings, explanations, markdown, or text outside the JSON object.
JSON Schema: {insert_json_schema_here}
Input Data: {insert_input_data_here}