LLM Response

LLMs return text that your application must often parse and validate before use. The model can provide plain strings, semi-structured text, or strictly structured formats (JSON, CSV, XML). Because LLM outputs can vary in formatting and content, you should design a robust parsing and validation layer that coerces or rejects unexpected formats and normalizes values (dates, numbers, enums) before further processing. For example, when an LLM supplies a date string, you must parse and validate that string so it can be converted into a proper date object for arithmetic. The more explicit you are about the expected output schema in the prompt, the easier and safer parsing becomes.

After receiving the LLM response, apply these steps in order:

Detect the format (plain text vs. requested JSON/CSV/XML).
Validate the structure (required keys, value types, allowed enums).
Normalize values (parse ISO-8601 dates, trim whitespace, coerce numbers).
Apply domain-specific checks (ranges, cross-field consistency).
Fail fast or fallback to safe defaults when validation fails.

Always ask the LLM for a clear output format (for example, JSON with explicit keys). Validate and sanitize the returned data before using it in production. Consider schema validation libraries (e.g., pydantic, jsonschema) for reliable enforcement.

Example: parsing an ISO-8601 date string returned by the LLM and computing the difference in days (Python)

from datetime import date

# Suppose the LLM returned this ISO-8601 date string:
llm_date_str = "2026-07-16"

# Convert to a date object and compute difference
date_from_llm = date.fromisoformat(llm_date_str)
today = date.today()

delta = today - date_from_llm
print(f"Days between: {abs(delta.days)}")

Notes for Python example:

Prefer date.fromisoformat() for YYYY-MM-DD. It raises ValueError for invalid formats, which you should catch and handle.
For timestamps with time and timezone, use datetime.fromisoformat() or a robust parser like dateutil.parser.isoparse().

Example: parse a date string in JavaScript and compute days difference

const llmDateStr = "2026-07-16";
// Parse as UTC midnight to avoid local timezone interpretation of "YYYY-MM-DD"
const dateFromLLM = new Date(llmDateStr + "T00:00:00Z");
const today = new Date();

const msPerDay = 24 * 60 * 60 * 1000;
const diffDays = Math.abs(Math.round((today - dateFromLLM) / msPerDay));
console.log(`Days between: ${diffDays}`);

Notes for JavaScript example:

Appending "T00:00:00Z" forces UTC parsing for YYYY-MM-DD inputs and avoids off-by-one-day errors from local timezone offsets.
For more complex datetime handling, consider a library like luxon or date-fns.

Key practices for reliably consuming LLM output

Area	Recommendation	Example / Tools
Output schema	Request a strict format (e.g., `JSON` with explicit keys)	Prompt: `Return {"date": "YYYY-MM-DD", "reason": "..."}`
Validation	Use schema validation and type checks	`jsonschema`, `pydantic`, `zod`
Date parsing	Prefer ISO-8601; specify exact format in prompt	`date.fromisoformat()`, `dateutil`, `luxon`
Error handling	Provide safe fallbacks and clear error messages	Retry, ask the model to reformat, or reject input
Security	Never trust unvalidated LLM output in security- or safety-critical flows	Sanitize before executing or storing

Do not execute or evaluate code, commands, or markup produced by an LLM without strict validation. Treat LLM output as untrusted data: validate structure, types, ranges, and content before use.

Example prompt patterns you can use to force structured output

Minimal JSON schema prompt:

text provided to analyze; awaiting input."}

Return a JSON object with keys: "date" (YYYY-MM-DD), "summary" (short string).

JSON schema with validation hints:

"status":"pending"}

Return JSON: {"date":"YYYY-MM-DD", "status":"one of [approved, denied, pending]"}

References and further reading

JSON Schema: https://json-schema.org/
Python date handling (datetime): https://docs.python.org/3/library/datetime.html
ISO 8601 date format overview: https://en.wikipedia.org/wiki/ISO_8601
JavaScript Date pitfalls and timezone handling: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

By specifying explicit output formats, validating responses, and normalizing values, you make LLM-driven applications more robust, predictable, and secure.

Introduction

Overview of LangChain

Key Components of LangChain

Interacting with LLMs

Tips, Tricks, and Resources

Introduction to LCEL

Adding Memory to LLM Apps

Performing Retrieval

Implementing Chains

Using Tools

Building Agents

Conclusion

Building Blocks of LLM Apps

Watch Video