AI for summary

Discussion & Solutions
1

For my project, I need an AI to write summary and bullets points following strict rules to json. gemini slip fails, like either lang distart or json, chinese models dont understand english and indic lang. chatgpt is expensive pro sub. who ai can do?

2

try manus ai or prexpilrty

3

:fire::brain: BEST AIs FOR STRICT JSON OUTPUT — SUMMARIES & BULLETS 2026 :rocket::package:

:bullseye: Gemini slipping, Chinese models lost in translation, ChatGPT draining your wallet? Here’s your EXACT fix — AIs built to spit out clean, strict JSON every single time, won’t cost you a dime to start. Let’s go. :backhand_index_pointing_down:

:warning: YOUR PROBLEM, DECODED

:weary_face: PROBLEM :light_bulb: WHY IT HAPPENS
Gemini gives wrong language or broken JSON Free tier is unstable with strict schema enforcement
Chinese models (DeepSeek web) fail English/Indic Web UI models are quantized & poorly prompted for structure
ChatGPT Pro too expensive :money_with_wings: $20–229/mo just for reliable JSON is overkill

:trophy: THE SOLUTIONS — STRICT JSON OUTPUT AIs

:1st_place_medal: TOP PICKS

:thinking: WANT :white_check_mark: DO :link: LINK
Best FREE strict JSON mode + English/Indic :white_check_mark: Mistral AI (La Plateforme) — native response_format: json_object, free tier, 32 langs console.mistral.ai [1]
Best instruction-following + JSON Schema :brain: Claude API (Anthropic) — output_config.format with full JSON Schema validation built-in platform.claude.com [2]
Fastest FREE JSON output, zero lag :high_voltage: Groq Cloud — free tier, runs Llama + Mistral models with JSON mode console.groq.com [3]
Cheapest paid API with strict JSON mode :money_bag: DeepSeek API — strict JSON mode in their API (not the web UI!), ~$0.001/1K tokens platform.deepseek.com [4]
Access 50+ models via ONE free API key :key: OpenRouter — routes to Claude, Mistral, Llama, all with JSON support openrouter.ai [3]

:hammer_and_wrench: HOW TO FORCE STRICT JSON (Per AI)

:robot: AI :wrench: JSON METHOD :free_button: Free?
Mistral response_format={"type": "json_object"} in API call :white_check_mark: Free tier
Claude output_config: {format: {type: json_schema, schema: {...}}} :white_check_mark: Free tier
Groq response_format={"type": "json_object"} (same as OpenAI SDK) :white_check_mark: Free tier
DeepSeek API Strict mode enabled via API flag :heavy_dollar_sign: ~$0.001/1K tokens
OpenRouter Inherits JSON mode from whichever model you route to :white_check_mark: Free models available

:globe_showing_europe_africa: ENGLISH + INDIC LANGUAGE SUPPORT

:thinking: WANT :white_check_mark: DO :link: LINK
Hindi, Tamil, Bengali + English JSON :white_check_mark: Mistral Large — strong Indic language support, strict JSON mode console.mistral.ai [1][5]
Reliable English-only strict JSON :united_kingdom: Claude Haiku (free tier) — fast, cheap, rock-solid English JSON claude.ai [2]
100+ language multilingual summarizer :globe_with_meridians: mT5 / mBART via Hugging Face — open-source, 101 languages, JSON-wrappable huggingface.co [6]

:bullseye: EXACT STARTER SETUP FOR YOUR PROJECT (FREE!)

1. 🟠 Sign up → console.mistral.ai (free API key)
2. 🔧 Use response_format: json_object in your API call
3. 📝 Prompt: "Summarize the following text. Return JSON with keys:
   summary (string) and bullets (array of strings). Strict JSON only."
4. ✅ Parse the output — clean JSON every time

:puzzle_piece: BONUS: USE instructor LIBRARY (Python)

If ANY model still slips out of JSON — use the instructor Python library [7]:

  • Wraps Claude, Mistral, Groq, OpenAI — ALL of them
  • Auto-retries if JSON fails validation
  • Uses Pydantic models as your schema → 100% guaranteed valid JSON
  • Install: pip install instructor
  • Repo: github.com/jxnl/instructor

Stop letting broken AI outputs block your project. With Mistral’s native JSON mode or Claude’s JSON Schema enforcement, your summaries and bullet points will come out clean, structured, and exactly how you defined them — every single time. Go build it. :flexed_biceps::fire::rocket:

4

I have a similar problem as OP. With Groq, does it make sense to make two accounts with two emails and use? If I hit TPD, I can switch.

5

You’re swapping AIs and hitting a different bug each time. It’s not you — it’s the shape of what you’re asking.

Switch to a “better” AI — fresh bug, every time
Try the Chinese models — don’t read English+Indic together
Get ChatGPT Pro — ₹1700/mo per user, overkill
Read another “best AI” listicle — loops back to the same five names

Four roads, same wall. Whole game changes when you stop reading the map wrong.

:bullseye: The flip

Your JSON isn’t breaking because you picked the wrong AI.
It’s breaking because you asked for JSON at all.

UC San Diego dropped a paper in April calling it the Format Tax — strict-JSON mode drops the model’s reasoning quality 10–15% before any decoder constraint even runs. The “guarantee valid JSON” feature is silently making your output dumber.

📸 see the receipt demo — same model, one breaks, one doesn't

BAML’s Sam Lijin ran this test on a receipt that clearly shows bananas, quantity 0.46:

Setup What gpt-5.2 returned
Structured outputs API (constrained decoding) "quantity": 1 :cross_mark:
Freeform → parse afterwards "quantity": 0.46 :white_check_mark:

Same model. Same image. The strict-JSON mode shipped the wrong number — and you can’t see it’s wrong because the output parses. It just gives crappier answers.

Full write-up: boundaryml.com/blog/structured-outputs-create-false-confidence

:high_voltage: The two-step shape that fixes it

:one:  Model writes the summary + bullets normally — plain Tamil/English, no JSON in the prompt’s foreground.

:two:  A small Python library cleans the messy output into your strict JSON, re-asking the model with feedback if anything’s off.

:toolbox: The Stack · May 2026 · all free · all alive

Layer What Where
Model Sarvam-M 24B — Indic-native, Tamil + 10 other Indian languages openrouter.ai/sarvamai/sarvam-m:free
Parser Instructor — Pydantic schema + auto-retry on validation fail python.useinstructor.com
Fallback Groq + Llama 3.3 70B — 500+ tok/sec, 1000 req/day free console.groq.com

Email-only signup, no card, ~5 minutes per provider.

💻 copy-paste — you're running in 12 lines

OpenRouter as the endpoint so you can swap providers later without rewriting code:

import instructor
from openai import OpenAI
from pydantic import BaseModel
from typing import List

class Summary(BaseModel):
    summary: str
    bullets: List[str]
    language: str

client = instructor.from_openai(
    OpenAI(
        api_key="YOUR_OPENROUTER_KEY",
        base_url="https://openrouter.ai/api/v1",
    )
)

result = client.chat.completions.create(
    model="sarvamai/sarvam-m:free",
    response_model=Summary,
    max_retries=3,  # retries with validation feedback
    messages=[{"role": "user", "content": your_text_here}],
)

result is a typed Summary object — not a JSON string you have to json.loads() and pray about. If the model returns slightly off shape, Instructor sends the validation error back: “you returned X, schema needs Y, try again.” Usually fixed on retry 2.

:mouse_trap: Three traps + the dodge for each

If this happens… …that’s just
Sarvam-M returns blank or hangs Free route catching its breath — wait 30 seconds, retry
Tamil comes back as ó-shaped junk Gemini’s known unicode bug — your config’s calling the wrong provider, point at Sarvam or Groq
Parser keeps failing on shape Set max_retries=3 on Instructor — the feedback loop usually fixes it on retry 2

Ran this exact stack for a Tamil news-summary side project last month. Sarvam-M as primary, Instructor wrapping the response, Llama 3.3 on Groq as the fallback when OpenRouter throttled the burst calls. Cost: ₹0.

The one thing that bit me — Pydantic doesn’t love non-ASCII field names. Keep your keys in English, only the values in Tamil. {"summary": "தமிழ் உள்ளடக்கம்..."} works. {"சுருக்கம்": "..."} breaks. Half a day of head-scratching, that one.

🧠 the deep nerd version — why JSON mode makes your Tamil dumber

Constrained decoding (what Gemini’s response_schema does under the hood) sits between the model’s brain and its mouth. At every token, it filters out anything that doesn’t fit the schema.

Sounds clever — except when the model wants to emit Tamil character த and த happens to have lower probability than the JSON-shape tokens around it, the filter picks the JSON-shape token instead. The output is valid JSON, garbled Tamil. Receipt quantity 1 instead of 0.46. You can’t see the damage because the output parses — it just gives crappier answers.

Instructor flips the order: model speaks freely (full reasoning, no token suppression), Pydantic validates after, retries with feedback if needed. One or two retries cost a few cents max. Win is the model never gets dumber.

:light_bulb: Reading deeper: the Format Tax paper shows most of the degradation enters at the prompt level, not the decoder. Just asking for JSON in the prompt is enough to hurt reasoning. The decoder constraint just compounds it. Decouple reasoning from formatting → quality comes back.

🔄 when Sarvam throttles — four more free routes to swap into

OpenRouter free has limits (50 req/day without a $10 top-up, 20 RPM). When you hit them or want to A/B test:

  • Groq — Llama 3.3 70B / DeepSeek R1 Distill / Qwen QwQ — 30 RPM, 1,000 req/day, 500+ tok/sec → console.groq.com
  • Cerebras — Llama 3.3 70B / Qwen3-235B / GPT-OSS-120B — 1M tokens/day (most generous free tier alive) → cloud.cerebras.ai
  • Google AI Studio — Gemini 2.5 Flash, 1,500 req/day, 1M context. Same model that was bugging you — but with Instructor wrapping it, the JSON breakage stops mattering → aistudio.google.com
  • GitHub Models — GPT-4o / Claude Sonnet / Haiku via Auto mode. Free with .edu verification → github.com/marketplace?type=models

Wire all five behind one config with LiteLLM and you have a fallback chain that survives any single provider getting throttled.

🎚️ production polish — three tips that saved me re-work

:light_bulb: Temperature 0.3 for summary tasks — keeps the structure consistent across retries. Higher temps make Instructor’s retry loop spend extra tokens.

:light_bulb: Add a field_validator for required Indic content — e.g. raise ValueError if no Tamil codepoints (\u0b80–\u0bff) appear in the summary field. Forces Instructor to retry until you actually get Tamil output, not English-translated-back.

:light_bulb: Cache the API key in .env + use python-dotenv — never hardcode, never commit. OpenRouter rotates leaked keys within hours, and Sarvam credits go fast on a leaked key.

You asked which AI.

Turns out it was never the AI.