strictjson

A StrictJSON schema is a dictionary where keys are the field names and values define the constraints and types.

Value Formats:

• <description>, <datatype>: e.g., "starting with A, str"
• <description>, type: <datatype>: e.g., "between 5 to 12, type: int"
• <datatype>: e.g., "str" (no description provided)
• <description>: e.g., "Name of party" (datatype defaults to Any)

Supported Datatypes:

• Basic: str, int, float, bool
• Collections: List[type], Dict[key_type, value_type] (Note: list or dict without brackets default to List[Any] and Dict[str, Any])
• Complex: date, datetime, UUID, Decimal
• Special: Any, None, Optional[type], Union[type1, type2], and PEP 604 syntax (type1 | type2)
• Constraints: Enum['A', 'B', 'C'] (limits output to specific values)

Nesting: You can nest schemas using lists of dictionaries, e.g., [{'key': 'type'}] to ensure a list of specific objects.

This pattern demonstrates how to use strictjson to implement a Knowledge Graph (KG) based RAG (Retrieval-Augmented Generation) system. This approach can be more precise than raw context if the KG is extracted correctly.

Step 1: Extract Knowledge Graph

Use strict_json to convert raw text into a list of triplets (object_1, relation, object_2).

Step 2: Parse/Filter Knowledge Graph

Use strict_output to filter the full KG, keeping only the triplets relevant to the user's specific question. This reduces noise for the final LLM call.

Step 3: Answer Question

Use strict_json to pass the filtered KG and the question to the LLM, requesting a final structured answer.

# 1. Extract
res = strict_json(system_prompt=..., user_prompt=context, output_format=...)
kg = res['List of triplets']

# 2. Filter
res = strict_output(system_prompt=..., user_prompt=question, output_format=...)
parsed_kg = res['Parsed Knowledge Graph']

# 3. Answer
res = strict_json(system_prompt=..., user_prompt=question, output_format=...)
print(res['Answer'])

To use strictjson, you must provide a function that interfaces with your chosen LLM provider (e.g., OpenAI, Anthropic, or OpenRouter). This function must accept system_prompt and user_prompt and return the content string from the LLM response.

Example using OpenAI/OpenRouter:

import os
from openai import OpenAI

def llm(system_prompt: str, user_prompt: str, **kwargs):
    client = OpenAI(
        base_url="https://openrouter.ai/api/v1",
        api_key=os.environ["OPENROUTER_API_KEY"]
    )
    
    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    messages.append({"role": "user", "content": user_prompt})

    response = client.chat.completions.create(
        model="google/gemini-2.5-flash",
        messages=messages
    )
    return response.choices[0].message.content

def llm(system_prompt: str, user_prompt: str, **kwargs):
    from openai import OpenAI
    client = OpenAI(
        base_url="https://openrouter.ai/api/v1",
        api_key=os.environ["OPENROUTER_API_KEY"],
    )
    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    messages.append({"role": "user", "content": user_prompt})
    response = client.chat.completions.create(model=MODEL, messages=messages)
    return response.choices[0].message.content

StrictJSON allows you to define schemas concisely using a dictionary format. You can convert these schemas into Pydantic models to use with LLM providers like Gemini, or extract the JSON schema for direct LLM input.

Note for OpenAI users: Use convert_schema_to_openai_pydantic instead of the standard converter. The OpenAI API does not accept Any or dict datatypes, so this specific function converts them to str and List[] respectively to ensure compatibility.

from strictjson import convert_schema_to_pydantic

output_format = {"name": "Name of birthday party, str",
                 "date": "Any date in Mar 2026, date",
                 "participants": [{'Name': 'starting with A, str', 
                                   'Age': 'between 5 to 12, int'}]}

# Generates a Pydantic model (preferred for Gemini)
pydantic_model = convert_schema_to_pydantic(output_format)

# Generates JSON schema if required by the LLM
json_schema = pydantic_model.model_json_schema()

The parse_yaml function is a robust, model-agnostic way to get structured output from any LLM (ChatGPT, Claude, Gemini, etc.). It uses YAML for the prompt/output structure to reduce token usage and avoid escaping issues common with JSON. It automatically creates a Pydantic model for type checking and includes a retry mechanism (defaulting to 3 tries, configurable via num_tries) to fix mistakes.

To use it, you must provide an llm function that accepts system_prompt and user_prompt and returns a string.

from strictjson import parse_yaml

def my_llm_wrapper(system_prompt: str, user_prompt: str, **kwargs) -> str:
    # Your logic to call any LLM (OpenAI, Anthropic, etc.)
    # Must return the raw string response
    return "raw response string"

result = parse_yaml(
  system_prompt="You are a friendly assistant.",
  user_prompt="Write a blog post idea about AI in education",
  output_format={
    "title": "str",
    "tags": "List[str]",
    "published": "bool"
  },
  llm=my_llm_wrapper
)