feat: json schema

.gitignore

@@ -130,4 +130,5 @@ local_deploy.py
 test_vector_store_async.py
 deploy_sdk.py
 tests
-deploy_hf.py
+deploy_hf.py
+.mimocode

app/api/v1/chat.py

@@ -10,6 +10,7 @@ from fastapi.responses import StreamingResponse
 
 from app.api.deps import require_auth
 from app.services.chat_service import _stream_chat_completion, chat_completion
+from app.utils.schema_utils import validate_response_format
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +114,10 @@ async def create_chat_completion(
     temperature = body.get("temperature", 0.7)
     top_p = body.get("top_p", 0.9)
 
-    response_format = body.get("response_format", None)
+    try:
+        response_format = validate_response_format(body)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
 
     redis = getattr(request.app.state, "redis", None)
     scripts = getattr(request.app.state, "scripts", None)

app/api/v1/convert.py

@@ -63,6 +63,8 @@ async def _build_response(
     filename: Optional[str] = None,
     raw_data: Optional[bytes] = None,
     mappings: Optional[Dict[str, Dict[str, Any]]] = None,
+    json_schema: Optional[Dict[str, Any]] = None,
+    schema_name: str = "extraction",
     extraction_service: ExtractionService = None,
     clean_content: bool = False,
     text_cleaner_service: TextCleanerService = None,
@@ -84,6 +86,8 @@ async def _build_response(
             content,
             mappings,
             raw_data,
+            json_schema,
+            schema_name,
         )
         if "error" in json_result:
             error_message = json_result["error"]
@@ -146,6 +150,8 @@ async def convert_file(
     return_json: bool = Form(False),
     clean_content: bool = Query(False),
     mappings: Optional[str] = Form(None, description="JSON string with field mappings"),
+    json_schema: Optional[str] = Form(None, description="JSON Schema for AI-based structured extraction"),
+    schema_name: str = Form("extraction", description="Name for the JSON Schema"),
     token: str = Depends(require_auth),
     converter_service: ConverterService = Depends(get_converter_service),
     extraction_service: ExtractionService = Depends(get_extraction_service),
@@ -161,6 +167,13 @@ async def convert_file(
         except json_mod.JSONDecodeError:
             raise HTTPException(status_code=400, detail={"success": False, "message": "Invalid JSON in mappings parameter."})
 
+    parsed_schema = None
+    if json_schema:
+        try:
+            parsed_schema = json_mod.loads(json_schema)
+        except json_mod.JSONDecodeError:
+            raise HTTPException(status_code=400, detail={"success": False, "message": "Invalid JSON in json_schema parameter."})
+
     _logger.info("Received request to convert file: %s", file.filename)
     raw = await file.read()
     if len(raw) > _MAX_UPLOAD_BYTES:
@@ -188,6 +201,8 @@ async def convert_file(
         filename=file.filename,
         raw_data=raw,
         mappings=parsed_mappings,
+        json_schema=parsed_schema,
+        schema_name=schema_name,
         extraction_service=extraction_service,
         clean_content=clean_content,
         text_cleaner_service=text_cleaner_service,
@@ -236,6 +251,8 @@ async def convert_url(
                 filename=filename,
                 raw_data=raw_data,
                 mappings=body.mappings,
+                json_schema=body.json_schema,
+                schema_name=body.schema_name,
                 extraction_service=extraction_service,
                 clean_content=clean_content,
                 text_cleaner_service=text_cleaner_service,
@@ -258,6 +275,8 @@ async def convert_url(
         return_json=body.return_json,
         filename=filename,
         mappings=body.mappings,
+        json_schema=body.json_schema,
+        schema_name=body.schema_name,
         extraction_service=extraction_service,
         clean_content=clean_content,
         text_cleaner_service=text_cleaner_service,

app/models/schemas.py

@@ -70,6 +70,8 @@ class UrlRequest(BaseModel):
     url: str
     return_json: bool = False
     mappings: Optional[Dict[str, Dict[str, Any]]] = None
+    json_schema: Optional[Dict[str, Any]] = None
+    schema_name: str = "extraction"
 
     model_config = {"populate_by_name": True}
 

app/services/chat_service.py

@@ -22,7 +22,8 @@ from app.config import (
     OPENROUTER_MIMIKA_MODEL,
     get_settings,
 )
-from app.utils.json_utils import extract_json_blocks
+from app.utils.json_utils import extract_json_blocks, extract_single_json
+from app.utils.schema_utils import generate_schema_prompt, validate_against_schema
 
 logger = logging.getLogger(__name__)
 _settings = get_settings()
@@ -81,33 +82,60 @@ def inject_system_identity(
 
 def prepare_messages(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
 ) -> List[Dict[str, str]]:
-    if not response_format or response_format.get("type") != "json_object":
+    if not response_format:
         return messages
 
-    has_system = messages and messages[0].get("role") == "system"
+    rf_type = response_format.get("type")
 
-    if has_system:
+    if rf_type == "json_object":
+        has_system = messages and messages[0].get("role") == "system"
+        if has_system:
+            return [
+                {
+                    "role": "system",
+                    "content": f"{messages[0]['content']}\n\n{DEFAULT_JSON_PROMPT}",
+                },
+                *messages[1:],
+            ]
+        return [
+            {"role": "system", "content": DEFAULT_JSON_PROMPT},
+            *messages,
+        ]
+
+    if rf_type == "json_schema":
+        js = response_format.get("json_schema", {})
+        schema_prompt = generate_schema_prompt(
+            schema=js.get("schema", {}),
+            name=js.get("name", "response"),
+        )
+        has_system = messages and messages[0].get("role") == "system"
+        if has_system:
+            return [
+                {
+                    "role": "system",
+                    "content": f"{messages[0]['content']}\n\n{schema_prompt}",
+                },
+                *messages[1:],
+            ]
         return [
-            {
-                "role": "system",
-                "content": f"{messages[0]['content']}\n\n{DEFAULT_JSON_PROMPT}",
-            },
-            *messages[1:],
+            {"role": "system", "content": schema_prompt},
+            *messages,
         ]
 
-    return [
-        {"role": "system", "content": DEFAULT_JSON_PROMPT},
-        *messages,
-    ]
+    return messages
 
 
 def attach_json_content(
     response_data: Dict[str, Any],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
 ) -> None:
-    if not response_format or response_format.get("type") != "json_object":
+    if not response_format:
+        return
+
+    rf_type = response_format.get("type")
+    if rf_type not in ("json_object", "json_schema"):
         return
 
     try:
@@ -115,19 +143,38 @@ def attach_json_content(
         if not choices:
             return
         content = choices[0].get("message", {}).get("content", "")
-        if content:
-            parsed = extract_json_blocks(content)
-            if parsed:
-                response_data["parsed"] = (
-                    parsed[0] if len(parsed) == 1 else parsed
-                )
+        if not content:
+            return
+
+        parsed = extract_single_json(content)
+        if parsed is None:
+            response_data["parsed"] = {"error": "No valid JSON found in response"}
+            return
+
+        if rf_type == "json_schema":
+            schema = response_format["json_schema"].get("schema", {})
+            is_valid, validated_data, error_msg = validate_against_schema(parsed, schema)
+            if is_valid:
+                response_data["parsed"] = validated_data
+            else:
+                response_data["parsed"] = {
+                    "error": error_msg,
+                    "raw_output": parsed,
+                }
+        else:
+            # json_object - existing behavior
+            if isinstance(parsed, list) and len(parsed) == 1:
+                response_data["parsed"] = parsed[0]
+            else:
+                response_data["parsed"] = parsed
+
     except Exception as exc:
         response_data["parsed"] = {"error": str(exc)}
 
 
 async def call_openrouter_mimika(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,
@@ -265,7 +312,7 @@ async def call_meganova(
     redis: Redis,
     scripts: Dict[str, str],
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,
@@ -362,7 +409,7 @@ async def _get_next_aion_key(redis: Redis) -> Optional[str]:
 async def call_aion_labs(
     redis: Redis,
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     model: str = AION_LABS_DEFAULT_MODEL,
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
@@ -510,7 +557,7 @@ async def chat_completion(
 
 async def call_meganova_no_redis(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,
@@ -556,7 +603,7 @@ async def call_meganova_no_redis(
 
 async def call_aion_labs_no_redis(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     model: str = AION_LABS_DEFAULT_MODEL,
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
@@ -625,7 +672,7 @@ async def _stream_meganova(
     redis: Redis,
     scripts: Dict[str, str],
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,
@@ -697,7 +744,7 @@ async def _stream_meganova(
 
 async def _stream_meganova_no_redis(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,
@@ -741,7 +788,7 @@ async def _stream_meganova_no_redis(
 async def _stream_aion_labs(
     redis: Redis,
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     model: str = AION_LABS_DEFAULT_MODEL,
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
@@ -792,7 +839,7 @@ async def _stream_aion_labs(
 
 async def _stream_aion_labs_no_redis(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     model: str = AION_LABS_DEFAULT_MODEL,
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
@@ -836,7 +883,7 @@ async def _stream_aion_labs_no_redis(
 
 async def _stream_openrouter_mimika(
     messages: List[Dict[str, str]],
-    response_format: Optional[Dict[str, str]],
+    response_format: Optional[Dict[str, Any]],
     max_tokens: int = DEFAULT_MAX_TOKENS,
     temperature: float = DEFAULT_TEMPERATURE,
     top_p: float = DEFAULT_TOP_P,

app/services/extraction_service.py

@@ -17,6 +17,12 @@ from app.core.constants import (
     TABULAR_EXTENSIONS,
 )
 from app.core.logger import get_logger
+from app.models.domain import count_tokens
+from app.utils.json_utils import extract_single_json
+from app.utils.schema_utils import (
+    generate_schema_prompt,
+    validate_against_schema,
+)
 
 _logger = get_logger(__name__)
 _settings = get_settings()
@@ -471,12 +477,144 @@ class ExtractionService:
     def __init__(self) -> None:
         self._spacy_labels = VALID_SPACY_LABELS
 
+    async def extract_with_schema(
+        self,
+        markdown_text: str,
+        json_schema: Dict[str, Any],
+        schema_name: str = "extraction",
+        token_threshold: int = 10000,
+        model: str = "agentdeck-1.0",
+        provider: Optional[str] = None,
+        redis: Any = None,
+        scripts: Any = None,
+    ) -> Dict[str, Any]:
+        """Extract structured data from non-tabular file content using AI + JSON Schema.
+
+        Validates the schema, counts tokens, generates a schema-guided system prompt,
+        sends to AI, parses and validates the response against the schema.
+        """
+        from jsonschema import Draft202012Validator, SchemaError, ValidationError
+        from app.services.chat_service import chat_completion
+
+        # 1. Validate the JSON Schema
+        try:
+            Draft202012Validator.check_schema(json_schema)
+        except (ValidationError, SchemaError) as e:
+            return {
+                "error": f"Invalid JSON Schema: {e.message}",
+                "extractor": "ai_schema",
+            }
+
+        # 2. Count tokens using existing token counter
+        token_count = count_tokens(markdown_text)
+        _logger.info("Schema extraction: %d tokens in content", token_count)
+
+        if token_count >= token_threshold:
+            return {
+                "error": (
+                    f"Content has {token_count} tokens, exceeding threshold of "
+                    f"{token_threshold}. Content too large for schema extraction."
+                ),
+                "extractor": "ai_schema",
+                "token_count": token_count,
+            }
+
+        # 3. Generate schema-guided system prompt
+        system_prompt = generate_schema_prompt(schema=json_schema, name=schema_name)
+
+        # 4. Build messages and send to AI
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Extract structured data from the following content:\n\n{markdown_text}"},
+        ]
+
+        response_format = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": schema_name,
+                "strict": True,
+                "schema": json_schema,
+            },
+        }
+
+        try:
+            result = await chat_completion(
+                messages=messages,
+                model=model,
+                response_format=response_format,
+                max_tokens=12000,
+                temperature=0.0,
+                top_p=0.9,
+                provider=provider,
+                redis=redis,
+                scripts=scripts,
+            )
+        except RuntimeError as e:
+            return {
+                "error": f"AI request failed: {e}",
+                "extractor": "ai_schema",
+            }
+
+        # 5. Parse JSON from AI response
+        choices = result.get("choices", [])
+        if not choices:
+            return {
+                "error": "No response from AI",
+                "extractor": "ai_schema",
+            }
+
+        content = choices[0].get("message", {}).get("content", "")
+        if not content:
+            return {
+                "error": "Empty AI response",
+                "extractor": "ai_schema",
+            }
+
+        # Use existing parsed field if available (from attach_json_content)
+        parsed_from_result = result.get("parsed")
+        if parsed_from_result is not None:
+            if not isinstance(parsed_from_result, dict) or "error" not in parsed_from_result:
+                parsed_data = parsed_from_result
+            else:
+                parsed_data = None
+        else:
+            parsed_data = None
+
+        if parsed_data is None:
+            parsed_data = extract_single_json(content)
+
+        if parsed_data is None:
+            return {
+                "error": "Failed to extract JSON from AI response",
+                "extractor": "ai_schema",
+                "raw_response": content[:500],
+            }
+
+        # 6. Validate against schema
+        is_valid, validated_data, error_msg = validate_against_schema(parsed_data, json_schema)
+        if not is_valid:
+            return {
+                "error": f"Schema validation failed: {error_msg}",
+                "extractor": "ai_schema",
+                "raw_output": parsed_data,
+            }
+
+        return {
+            "success": True,
+            "extractor": "ai_schema",
+            "schema_name": schema_name,
+            "token_count": token_count,
+            "data": validated_data,
+        }
+
     def extract_structured(
         self,
         filename: Union[str, Path],
         markdown_text: str,
         mappings: Optional[Dict[str, Dict[str, Any]]] = None,
         file_data: Optional[bytes] = None,
+        json_schema: Optional[Dict[str, Any]] = None,
+        schema_name: str = "extraction",
     ) -> Dict[str, Any]:
         ext = Path(filename).suffix.lower()
 
@@ -486,11 +624,41 @@ class ExtractionService:
                 result["extractor"] = "pandas"
             return result
 
+        # JSON Schema path: delegate to async AI extraction
+        if json_schema:
+            import asyncio
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+
+            if loop and loop.is_running():
+                _logger.warning(
+                    "extract_structured called with json_schema from sync context; "
+                    "use extract_with_schema() directly for async callers"
+                )
+                return {
+                    "error": "JSON Schema extraction requires async context. Use extract_with_schema() instead.",
+                    "file_type": ext,
+                }
+
+            # Safe to run in a new event loop (CLI / test context)
+            result = asyncio.run(
+                self.extract_with_schema(
+                    markdown_text=markdown_text,
+                    json_schema=json_schema,
+                    schema_name=schema_name,
+                )
+            )
+            result["file_type"] = ext
+            return result
+
+        # Existing spaCy/regex path
         if not mappings:
             return {
                 "error": (
-                    f"Cannot extract JSON from '{ext}' files without field mappings. "
-                    "Provide a 'mappings' object with field extraction rules."
+                    f"Cannot extract JSON from '{ext}' files without field mappings or json_schema. "
+                    "Provide a 'mappings' object with field extraction rules, or a 'json_schema' for AI extraction."
                 ),
                 "file_type": ext,
             }

app/utils/json_utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import logging
 import re
-from typing import Any, List
+from typing import Any, List, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -39,3 +39,15 @@ def extract_json_blocks(text: str) -> List[Any]:
                     pass
 
     return blocks
+
+
+def extract_single_json(text: str) -> Optional[Any]:
+    """Extract a single JSON value from text, optimized for structured output.
+
+    Tries in order:
+    1. Parse entire text as JSON
+    2. Extract from ```json code fences
+    3. Find first {..} or [..] block
+    """
+    blocks = extract_json_blocks(text)
+    return blocks[0] if blocks else None

app/utils/schema_utils.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+from jsonschema import Draft202012Validator, SchemaError, ValidationError
+
+logger = logging.getLogger(__name__)
+
+
+def validate_response_format(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Validate the response_format field from the request body.
+
+    Accepts:
+      - {"type": "json_object"}
+      - {"type": "json_schema", "json_schema": {"name": "...", "strict": true, "schema": {...}}}
+
+    Returns the validated dict or None if response_format is absent.
+    Raises ValueError with a human-readable message on invalid input.
+    """
+    rf = body.get("response_format")
+    if rf is None:
+        return None
+
+    if not isinstance(rf, dict):
+        raise ValueError("response_format must be an object")
+
+    rf_type = rf.get("type")
+    if rf_type not in ("json_object", "json_schema"):
+        raise ValueError(
+            f"response_format.type must be 'json_object' or 'json_schema', got '{rf_type}'"
+        )
+
+    if rf_type == "json_object":
+        return rf
+
+    # json_schema path - validate the nested structure
+    js = rf.get("json_schema")
+    if not isinstance(js, dict):
+        raise ValueError("response_format.json_schema must be an object")
+
+    name = js.get("name")
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError("json_schema.name must be a non-empty string")
+
+    schema = js.get("schema")
+    if not isinstance(schema, dict):
+        raise ValueError("json_schema.schema must be a JSON Schema object")
+
+    strict = js.get("strict")
+    if strict is not None and not isinstance(strict, bool):
+        raise ValueError("json_schema.strict must be a boolean")
+
+    # Validate the schema itself is a valid JSON Schema
+    try:
+        Draft202012Validator.check_schema(schema)
+    except (ValidationError, SchemaError) as e:
+        raise ValueError(f"json_schema.schema is not a valid JSON Schema: {e.message}")
+
+    return rf
+
+
+def generate_schema_prompt(
+    schema: Dict[str, Any], name: str = "response"
+) -> str:
+    """Generate a system prompt that instructs the LLM to produce output
+    conforming to the given JSON Schema."""
+    schema_json = json.dumps(schema, indent=2)
+    field_instructions = _build_field_instructions(schema)
+
+    return (
+        f'You MUST respond with a single valid JSON object that conforms EXACTLY '
+        f'to this JSON Schema named "{name}":\n\n'
+        f"```json\n{schema_json}\n```\n\n"
+        "CRITICAL RULES:\n"
+        "1. Your entire response must be ONLY a JSON object. No text before or after.\n"
+        "2. Do NOT wrap the JSON in markdown code fences or any other formatting.\n"
+        "3. Every required field MUST be present in your response.\n"
+        "4. Use ONLY the types specified in the schema (string, number, integer, boolean, array, object, null).\n"
+        "5. Do NOT include any fields that are not defined in the schema properties.\n"
+        '6. For "enum" fields, use EXACTLY one of the specified values.\n'
+        '7. For "const" fields, use the exact specified value.\n'
+        "8. For nested objects, follow the sub-schema recursively.\n\n"
+        f"{field_instructions}\n\n"
+        "Respond with ONLY the JSON object - no explanation, no markdown, no code fences."
+    )
+
+
+def _build_field_instructions(
+    schema: Dict[str, Any], prefix: str = ""
+) -> str:
+    """Recursively build human-readable field instructions from a schema."""
+    lines: list[str] = []
+    props = schema.get("properties", {})
+    required = set(schema.get("required", []))
+
+    for field_name, field_schema in props.items():
+        full_name = f"{prefix}{field_name}" if prefix else field_name
+        field_type = field_schema.get("type", "any")
+        is_required = field_name in required
+
+        status = "REQUIRED" if is_required else "optional"
+        desc = field_schema.get("description", "")
+
+        if field_type == "string" and "enum" in field_schema:
+            enum_vals = ", ".join(f'"{v}"' for v in field_schema["enum"])
+            line = f'- Field "{full_name}" ({status}): Must be one of [{enum_vals}].'
+        elif field_type == "string" and "format" in field_schema:
+            fmt = field_schema["format"]
+            line = f'- Field "{full_name}" ({status}): type=string, format="{fmt}".'
+        elif field_type == "array" and "items" in field_schema:
+            items = field_schema["items"]
+            item_type = items.get("type", "any")
+            line = f'- Field "{full_name}" ({status}): type=array of {item_type}.'
+        elif field_type == "object" and "properties" in field_schema:
+            nested = _build_field_instructions(field_schema, prefix=f"{full_name}.")
+            if nested:
+                lines.append(f'- Field "{full_name}" ({status}): nested object with fields:')
+                lines.append(nested)
+            continue
+        elif field_type == "null":
+            line = f'- Field "{full_name}" ({status}): can be null.'
+        else:
+            line = f'- Field "{full_name}" ({status}): type={field_type}.'
+
+        if desc:
+            line = line.rstrip(".") + f". {desc}"
+        lines.append(line)
+
+    if not schema.get("additionalProperties", True):
+        lines.append("- Do NOT include any additional properties not listed above.")
+
+    return "\n".join(lines) if lines else ""
+
+
+def validate_against_schema(
+    data: Any, schema: Dict[str, Any]
+) -> Tuple[bool, Any, Optional[str]]:
+    """Validate data against a JSON Schema.
+
+    Returns:
+        (is_valid, data, error_message_or_None)
+    """
+    try:
+        validator = Draft202012Validator(schema)
+        validator.validate(data)
+        return True, data, None
+    except ValidationError as e:
+        path = (
+            ".".join(str(p) for p in e.absolute_path)
+            if e.absolute_path
+            else "(root)"
+        )
+        msg = f"Validation error at '{path}': {e.message}"
+        return False, data, msg

pyproject.toml

@@ -31,6 +31,7 @@ dependencies = [
     "seaborn>=0.13.0",
     "spacy>=3.7.0",
     "phonenumbers>=8.13.0",
+    "jsonschema>=4.21.0",
 ]
 
 [project.optional-dependencies]

requirements.txt

@@ -55,3 +55,6 @@ chardet>=5.2.0
 clean-text>=0.6.0
 text-unidecode>=1.3
 Unidecode>=1.3.8
+
+# JSON Schema validation
+jsonschema>=4.21.0