567-labs/instructor

Features

• Structured Data Extraction - Transforms unstructured text into validated, type-safe objects using schema definitions and model-specific tool-calling capabilities.
• Structured Output Parsers - Provides a framework for transforming unstructured text into validated, type-safe objects using schema definitions and automated validation-based retry loops.
• LLM Integration Frameworks - Provides a unified interface for interacting with diverse language model providers while maintaining consistent extraction and error handling.
• Model Provider Interfaces - Provides a unified client interface to interact with diverse language model providers, allowing developers to switch backends without changing core logic.
• Structured Output Enforcements - Validates model responses against defined schemas and automatically retries requests when outputs fail to match constraints.
• Structural Data Validators - Verifies language model outputs against defined data structures and executes custom logic during the extraction lifecycle.
• Validation-Based Retry Loops - Automatically re-submits requests with error feedback when initial outputs fail validation, improving the reliability of structured data extraction.
• Model Provider Adapters - Normalizes input formats and parameter naming conventions to allow seamless switching between different model provider message structures.
• Model Provider Abstractions - Normalizes diverse model API interfaces into a unified execution layer for consistent request handling and response parsing.
• Structured Collection Extraction - Process inputs to return an iterable collection of structured objects when the model is tasked with generating multiple results.
• Schema-Enforced Output Parsers - Constrains and parses model outputs into predefined data structures with automated retry logic.
• Client Provider Patching - Enhances existing model client interfaces to support structured output extraction and automated error handling through a unified configuration API.
• Data Schema Validation - Enforces type safety and data integrity by validating model outputs against defined schemas.
• Retry Policies - Automatically re-submits failed model responses with error feedback to iteratively correct schema compliance and data integrity.
• Model Provider Integrations - Provides a unified interface to interact with various language model providers while maintaining consistent extraction logic.
• Command Error Correction Engines - Retries requests upon validation errors to iteratively correct malformed model responses.
• Extraction Mode Selection - Automatically chooses between tool-calling or JSON-based output formats based on the capabilities of the underlying model.
• Validation-Based Retries - Automatically re-attempts extraction requests when model outputs fail schema validation.
• Parallel Tool Execution - Invoke several functions in a single request to reduce latency by processing multiple structured data extraction tasks simultaneously.
• Reasoning Trace Integration - Embeds step-by-step thought processes within data models to improve the accuracy and quality of extracted information from language models.
• Prompt-Based Schema Enforcement - Uses class docstrings and field annotations to automatically generate instructions for language models during extraction.
• Automated Data Extraction - Automatically re-executes extraction requests upon validation failure or API errors to ensure reliable data retrieval.
• Incremental Structured Streamers - Yields validated data objects as they are generated to enable real-time consumption of structured outputs.
• Nested Object Mapping - Maps complex, hierarchical information from natural language into nested object models to represent relationships and collections.
• Nested Schema Mapping - Parses complex, hierarchical information from model outputs into deeply nested schema models to maintain data integrity across multi-level relationships.
• Schema-Driven Data Modeling - Generates model instructions by introspecting class definitions and field annotations to ensure structured output alignment.
• Client Middleware Extensions - Injects validation and retry logic into existing client objects without modifying their original source code.
• Incremental Data Streamers - Delivers validated data objects incrementally as they are generated to enable real-time consumption before completion.
• Token Usage Analytics - Retrieves detailed token consumption metrics from model responses to monitor costs and manage context window limits.
• Enterprise AI Integration Tools - Connects to managed cloud-hosted language models to enable structured data extraction with enterprise-grade security and compliance features.
• External Knowledge Integrators - Integrates web search and file retrieval to provide models with real-time information and private knowledge access.
• Multimodal Input Processors - Extracts semantic information from images, audio files, and PDFs by automatically converting local or remote file references into model-compatible formats.
• Multimodal Processing - Ingests images, audio, and PDF files from local paths, URLs, or base64 strings to include them in structured data extraction requests.
• Prompt Templates - Generates prompts using template engines to inject variables into requests before sending them to model providers.
• API-Integrated Extraction - Defines schema models to enforce type-safe data extraction from language model responses within web service endpoints.
• Asynchronous Extraction Engines - Processes model responses into validated objects using non-blocking calls to maintain application responsiveness.
• AI and Agents - A library for extracting structured data from LLMs, powered by Pydantic.
• Data Validation - Enforces custom business logic and formatting rules on extracted data before final processing.
• Data Standardization - Uses enumerations or literal types to restrict field values to a predefined set, ensuring consistent and predictable output formats.
• Polymorphic Response Handling - Allows the model to return one of several different data structures or a list of mixed types to support flexible, multi-intent interactions.
• Model Interaction Inspectors - Captures request and response data to facilitate debugging and transparency in model interactions.
• Lifecycle Event Hooks - Allows custom logic injection at specific stages of the extraction process for monitoring, logging, and error handling.
• Schema Modularization - Defines modular data structures that can be applied across multiple fields or contexts within a larger model definition.
• Schema Mapping Tools - Supports complex data structures by dynamically resolving union types and nested objects into validated application models.
• AI Cost Monitoring - Tracks the financial cost associated with individual model requests to monitor and manage usage expenses.
• Extraction Process Observers - Captures full interaction history between the application and the model for performance monitoring.
• Parallel Tool Execution - Executes multiple extraction tasks simultaneously to improve throughput for complex data requirements.
• External Tool Execution - Invokes predefined functions during extraction to provide models with additional context and capabilities.
• Tool Calling - Maps union types to provider-specific tool calling capabilities to generate multiple distinct structured outputs in one request.
• Raw Completion Retrieval - Returns the structured data alongside the original provider response object to allow access to metadata and raw completion details.
• Inference Parameters - Configures inference parameters such as temperature and stop sequences for precise control over model output.
• Function Calling Fine-Tuning - Captures function calls and arguments to generate high-quality training data for fine-tuning models.
• Model Parameter Configurations - Adjusts model generation parameters like randomness and token limits to fine-tune the extraction process.
• Prompt Caching - Stores recurring segments of a prompt to minimize redundant processing and decrease latency and costs.
• Reasoning Extenders - Configures models to perform multi-step reasoning before returning structured data to improve accuracy.
• Reasoning Trace Retrievers - Retrieves internal chain-of-thought reasoning processes alongside structured output for transparency and debugging.
• Synchronous Extraction Handlers - Processes model responses into validated objects using schema definitions to ensure output matches expected structures.
• Dynamic Schema Extensions - Constructs data models at runtime based on external configurations to support flexible extraction requirements.
• Semantic Content Validators - Verifies content quality, tone, and factual accuracy using secondary model passes.
• Extraction Failure Monitors - Hooks into the processing lifecycle to log or respond to specific extraction error types.
• Contextual Data Validators - Validates extracted content against external runtime information or source documents.
• Structured Collection Streams - Yields individual items from a generated list incrementally to reduce latency.
• Response Caching - Stores structured data extraction outputs in memory or disk to avoid redundant processing and decrease response times.
• Model Metadata Retrieval - Returns the structured data alongside the original provider response object to allow access to usage statistics, finish reasons, and other metadata.
• Citation Validators - Verifies that quotes used in structured data exist within the provided source text.
• Fallback Schemas - Provides structured fallback mechanisms to handle missing data and reduce hallucinations during extraction.
• Extraction Failure Trackers - Captures and exposes detailed histories of failed extraction attempts to facilitate debugging and iterative correction.
• Asynchronous Extraction Job Management - Lists, retrieves, and processes results from asynchronous extraction tasks using type-safe patterns to handle both successful outputs and potential errors.
• Extraction Error Handlers - Catches and reports failures related to schema validation and incomplete model outputs.
• Interaction Event Interceptors - Executes custom logic during the request lifecycle for logging and monitoring model interactions.
• Value Constraint Enforcers - Restricts model responses to predefined options using enumerations to ensure consistency.
• Schema Metadata Utilities - Annotates data models with titles, descriptions, and examples to guide the language model during extraction.
• Schema Metadata Definitions - Annotates data models with metadata and validation context to improve the quality of structured output.
• Extraction Execution Tracers - Outputs diagnostic information about model requests and provider initialization for debugging workflows.
• Batch Processing - Groups multiple data extraction tasks into a single operation to reduce costs and improve efficiency across supported language model providers.
• Lifecycle Event Interceptors - Registers callbacks for specific stages of the extraction process like parsing or completion.
• Asynchronous Model Execution - Provides non-blocking execution of extraction tasks to maintain high throughput and application responsiveness.
• Extraction Fallback Logic - Executes alternative strategies or relaxed models when primary extraction attempts fail.
• Provider-Specific Extraction Adapters - Maps natural language input to validated schema objects while automatically handling message format conversions for specific providers.
• Multimodal Document Processing - Extracts semantic information from multimodal documents like images and PDFs to populate structured data models.
• Extraction Mode Configurators - Allows selecting between raw text parsing and native tool-calling APIs to optimize data retrieval.
• Cloud File Uploaders - Integrates with cloud-based file APIs to handle the upload and processing of documents directly within the data extraction workflow.
• Input Caches - Stores previously processed text and media inputs to reduce latency and operational costs for identical content.
• Enumeration Types - Constrains model responses to a predefined set of valid values using schema definitions to ensure data consistency.
• Extraction Configurations - Configures underlying protocols like tool calling or constrained grammar sampling to optimize data extraction.
• Response Format Configurators - Ensures compatibility with model providers by selecting between native tool calling, raw JSON, or markdown-wrapped JSON.
• Entity Relationships - Models connections between data entities using unique identifiers and reference lists to represent complex structures.
• Cross-Field Validators - Evaluates logical consistency and relationships between multiple fields within a data model.
• File Upload Management - Integrates with remote file storage services to process external assets directly within the data extraction workflow.
• Dynamic Property Mapping - Capture undefined or dynamic attributes by mapping them into a list of key-value pairs within the structured schema.
• Model Output Caches - Saves previous computation results in memory to prevent redundant processing and lower costs for identical prompts.
• Response Streaming - Streams generated data chunks to clients in real-time to improve perceived performance for large outputs.
• Incremental Union Streams - Yields partial structured data for polymorphic union types as they are generated.
• Partial Response Streams - Yields data incrementally to allow real-time processing of structured objects before the full response is complete.
• Asynchronous Request Execution - Executes non-blocking data extraction operations to maintain responsiveness during long-running model requests.
• Safety Threshold Managers - Applies harm thresholds to text and image inputs to prevent content violations while ensuring compatibility.
• Dynamic Validation Rules - Enables dynamic validation checks by passing external runtime information into validation routines.
• Context Overflow Handlers - Manages exceptions triggered by token limits by dynamically adjusting prompts or constraints.

Star history