Pydantic on AI VOID

Chapter 3: Defining Your Extraction Task and Schema

Mon, 05 Jan 2026 00:00:00 +0000

Chapter 3: Defining Your Extraction Task and Schema

Welcome back, future data alchemists! In the previous chapter, we got LangExtract up and running and connected to our chosen Large Language Model (LLM) provider. That’s a huge step! Now, it’s time to get down to the real magic: telling LangExtract exactly what kind of information we want to pull out of unstructured text.

This chapter is all about defining your “extraction task” and creating a “schema” – essentially, a blueprint for the structured data you expect to receive. This is arguably the most crucial part of using LangExtract effectively. Without a clear schema, an LLM might give you inconsistent, incomplete, or even hallucinated results. With a well-defined schema, you guide the LLM to focus its powerful understanding on precisely what you need, making your extractions reliable and robust.

Handle Data Input: Pydantic Models & Request Bodies

Sat, 25 Oct 2025 00:00:00 +0000

Chapter Title: Handle Data Input: Pydantic Models & Request Bodies

What You’ll Learn

How to receive data sent by clients using HTTP POST requests.
Understanding the concept of a “request body” in API communication.
How to define structured data schemas for incoming data using Pydantic’s BaseModel.
Leveraging FastAPI’s integration with Pydantic for automatic data validation.
How Pydantic automatically serializes incoming JSON data into Python objects for easy use.

Core Concepts

Receiving Data with POST Requests and Request Bodies

When clients (like a web browser, mobile app, or another server) want to send data to your API to create a new resource (e.g., a new user, a new product) or submit information, they typically use an HTTP POST request. Unlike GET requests, where data is appended to the URL as query parameters, POST requests send data in the request body.

Building the Agentic Core: STT to LLM to Intent Mapping

Wed, 06 May 2026 00:00:00 +0000

In this chapter, we’re building the brain of our on-device AI agent: the core pipeline that translates user speech into actionable intents. This involves taking transcribed text, feeding it into a tiny, local Large Language Model (LLM), and then extracting a structured understanding of what the user wants to do. This is a critical step towards enabling truly intelligent, privacy-preserving interactions on edge devices.

By the end of this milestone, you will have a functional Python script that can:

Your First Full CRUD API: Items Manager Project

Sat, 25 Oct 2025 00:00:00 +0000

Your First Full CRUD API: Items Manager Project (covering: Project Setup: Structuring Your FastAPI Application, Implement CREATE (POST) Operations for Items, Implement READ (GET) Operations: All and By ID)

What You’ll Learn

In this chapter, you’ll embark on building your very first complete set of API operations for managing “items.” By the end, you will be able to:

Structure a basic FastAPI project: Organize your code into logical files for better maintainability.
Define data models with Pydantic: Learn how to use Pydantic BaseModel to validate incoming request data and define outgoing response data.
Implement CREATE (POST) operations: Create an endpoint that allows clients to add new items to your application.
Implement READ (GET) operations: Build endpoints to retrieve all items and to fetch a specific item by its unique identifier.
Handle in-memory data storage: Understand how to simulate a database using simple Python data structures for learning purposes.

Core Concepts

Project Setup: Structuring Your FastAPI Application

As your FastAPI application grows, putting everything into a single main.py file can become unwieldy. A good practice is to separate concerns. For our Items Manager project, we’ll start with a simple structure:

Designing & Building Comprehensive Guardrail Systems

Fri, 20 Mar 2026 00:00:00 +0000

Introduction

Welcome to Chapter 11! In our previous chapters, we delved into the crucial aspects of evaluating and testing AI systems before and during deployment. We explored prompt engineering, regression testing, and methods to detect issues like hallucination. But what happens when an AI system is live, interacting with users in the real world? How do we ensure it consistently behaves as intended, adheres to safety guidelines, and remains compliant with regulations?

Chapter 14: Project: Extracting Key Information from Legal Contracts

Mon, 05 Jan 2026 00:00:00 +0000

Chapter 14: Project: Extracting Key Information from Legal Contracts

Welcome back, future data architects! In our previous chapters, we laid the groundwork for understanding LangExtract, setting up our environment, and performing basic extractions. You’ve seen how powerful Large Language Models (LLMs) can be when guided by a structured schema.

In this chapter, we’re going to put all that knowledge to the test with a practical, high-value project: extracting key information from legal contracts. Legal documents are notoriously complex, filled with jargon, and often lengthy, making them a perfect challenge for LangExtract’s capabilities. By the end of this chapter, you’ll have built a system to automatically pull out crucial details like parties involved, effective dates, and contract values from sample legal text. This isn’t just about coding; it’s about building confidence in tackling real-world, complex data extraction problems.

Chapter 15: Project: Summarizing and Structuring Financial Reports

Mon, 05 Jan 2026 00:00:00 +0000

Chapter 15: Project: Summarizing and Structuring Financial Reports

Welcome back, intrepid data explorer! In our previous chapters, you’ve mastered the fundamentals of LangExtract, from setting up your environment to crafting precise extraction schemas and understanding the nuances of prompt engineering. Now, it’s time to put those skills to the test with a real-world, highly valuable application: extracting structured information from financial reports.

Financial reports, such as earnings call transcripts, annual reports, or quarterly statements, are treasure troves of critical business data. However, sifting through pages of unstructured text, tables, and disclosures to find specific metrics or key highlights can be incredibly time-consuming. This chapter will guide you through building a LangExtract solution to automate this process, allowing you to quickly pull out crucial financial data points and summarize key sections.

Build a REST API with FastAPI

Tue, 26 May 2026 00:00:00 +0000

What you’ll build: A functional REST API using FastAPI, demonstrating setup, route definition, data validation, dependency injection, and testing. Time needed: ~75 minutes Prerequisites: Python 3.8 or newer, Basic understanding of Python, Familiarity with REST API concepts Version used: 0.115.6

FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.8+ based on standard Python type hints. It’s designed to be easy to use, highly performant, and automatically generate interactive API documentation. In this tutorial, we’ll walk through building a complete, yet simple, REST API from scratch, covering the core features that make FastAPI a joy to work with.

Chapter 8: User Registration and Login Flow

Wed, 20 Aug 2025 00:00:00 +0000

While we introduced basic user registration and login in Chapter 4, this chapter focuses on refining these critical endpoints. We’ll ensure robust data validation, provide clear error messages, and integrate the user management more tightly with our database. This is about building a solid, production-ready authentication foundation.

Purpose of this Chapter

By the end of this chapter, you will:

Have dedicated endpoints for user registration and login.
Understand data validation for incoming user data.
Implement proper password hashing and verification.
Ensure that authenticated users are correctly identified and used throughout the application.

Concepts Explained: Data Validation & Error Handling

Data Validation: Ensuring that incoming data (like username and password during registration) meets expected criteria. FastAPI leverages Pydantic for this, which allows you to define strict schemas for your request bodies.