How can I efficiently validate and auto-correct JSON inputs for dynamic function calls in Python?

Below is an approach that others have been adopting by leveraging Pydantic’s improved JSON validation and custom validators.

Leveraging Pydantic 2.10 for Faster, Flexible Validation

Pydantic 2.10 introduces a validate_json method that validates JSON data directly against your schema. This avoids the overhead of converting between JSON and Python objects every time, which can be a performance win compared to using jsonschema. For example:

PYTHONCopied
from pydantic import TypeAdapter

json_data = '{"int_arg": 5, "float_arg": 2.1}'
# Assuming your schema is defined appropriately, you can validate directly:
result = TypeAdapter(YourSchema).validate_json(json_data)

Customizing Validators for Auto-Correction

If your application requires auto-correcting simple type errors (e.g., converting a string to an integer or ensuring that an array is formed even if a single value is supplied), you can add custom model validators. Pydantic lets you define pre- or post-validation methods that can adjust data as needed. For instance:

PYTHONCopied
from pydantic import BaseModel, field_validator

class MyFunctionInput(BaseModel):
    int_arg: int
    list_arg: list[str]

    # Pre-validator to auto-correct a mis-typed single string into a list of strings.
    @field_validator("list_arg", mode="before")
    def split_string_to_list(cls, v):
        if isinstance(v, str):
            return [v]
        return v

# Example usage:
data = {"int_arg": "42", "list_arg": "hello"}
validated = MyFunctionInput(**data)
# Autocorrection converts "hello" to ["hello"] and coerces "42" to 42
print(validated)

This flexibility lets you tailor how you handle input errors without resorting to multiple loops of manual jsonschema re-validation.

Integrating with LangChain’s Structured Outputs

LangChain supports both JSON Schema and TypedDict formats for defining structured outputs. When using these with Pydantic-backed validators, you can combine LangChain’s tool invocation mechanisms with Pydantic’s error handling. Custom validators (as shown above) can be particularly useful if you need to attempt an auto-correction before failing.

For example, when setting up a structured output in LangChain:

PYTHONCopied
json_schema = {
    "title": "joke",
    "description": "A joke to tell the user.",
    "type": "object",
    "properties": {
        "setup": {"type": "string", "description": "The setup of the joke"},
        "punchline": {"type": "string", "description": "The joke’s punchline"},
        "rating": {"type": "integer", "description": "A rating from 1 to 10"},
    },
    "required": ["setup", "punchline"],
}

structured_llm = llm.with_structured_output(json_schema)
response = structured_llm.invoke("Tell me a joke")

If you integrate custom validators in your underlying Pydantic models, you can implement auto-correction logic before invoking the language model again, similar to the “replace after selection” approach documented in LangChain.

Summary

• Performance: Pydantic’s validate_json directly validates JSON input, saving overhead compared to traditional conversion methods.
• Customization: Using custom validators (with pre- or post-model validation), you can auto-correct simple type mismatches.
• Integration: These approaches integrate smoothly with LangChain structured outputs, whether you’re using JSON Schema or TypedDict definitions.

This combination addresses the slow, token-expensive behavior you experienced with jsonschema and provides a route for incremental auto-correcting before falling back to a retry loop.

These solutions are documented in the LangChain error handling and structured output sections, as well as in the Pydantic 2.10 documentation.