{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"instructor","slug":"instructor","name":"Instructor","type":"framework","url":"https://github.com/jxnl/instructor","page_url":"https://unfragile.ai/instructor","categories":["frameworks-sdks"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"instructor__cap_0","uri":"capability://data.processing.analysis.pydantic.based.structured.output.validation","name":"pydantic-based structured output validation","description":"Intercepts LLM responses and validates them against Pydantic v1/v2 models before returning to the user. Uses schema introspection to extract field types, constraints, and nested structures, then validates JSON responses against the schema. Automatically retries on validation failures with error feedback injected back into the LLM context, enabling self-correction loops without manual prompt engineering.","intents":["I want to ensure LLM outputs match my data model schema without manual parsing","I need type-safe structured data from LLM calls with automatic validation","I want the LLM to fix its own output when it doesn't match my schema"],"best_for":["Python developers building LLM applications requiring strict type safety","Teams migrating from unstructured LLM outputs to production data pipelines","Builders prototyping multi-step agents with validated intermediate states"],"limitations":["Validation overhead adds ~50-200ms per response depending on schema complexity","Retry loops can increase token usage by 2-5x on complex schemas with strict constraints","Nested models with deep recursion (>5 levels) may cause context window exhaustion during retries","No built-in handling for circular references in Pydantic models"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","OpenAI, Anthropic, or other compatible LLM client library"],"input_types":["Pydantic BaseModel class definitions","LLM response text (JSON or structured format)"],"output_types":["Validated Pydantic model instances","Typed Python objects with full IDE autocomplete"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_1","uri":"capability://tool.use.integration.multi.provider.llm.client.patching","name":"multi-provider llm client patching","description":"Monkey-patches OpenAI, Anthropic, Cohere, and other LLM client libraries to intercept API calls and inject structured output validation. Wraps the native `create()` or `messages.create()` methods, preserving all original parameters and streaming behavior while adding validation as a transparent middleware layer. Supports both sync and async clients with identical APIs.","intents":["I want to add structured validation to my existing LLM client code with minimal changes","I need to switch between LLM providers without rewriting validation logic","I want streaming responses with partial object validation as data arrives"],"best_for":["Developers with existing OpenAI/Anthropic integrations wanting to add structure","Teams evaluating multiple LLM providers with consistent validation across all","Builders needing drop-in structured output without refactoring existing code"],"limitations":["Patching approach requires exact knowledge of each provider's API surface; breaking changes in client libraries can break Instructor","Async patching may not work with custom event loops or advanced concurrency patterns","No support for streaming with partial validation on providers that don't support streaming JSON","Patching happens at import time, making it difficult to use multiple versions of the same client"],"requires":["OpenAI>=1.0.0 OR Anthropic>=0.7.0 OR compatible client library","Python 3.9+","Pydantic v1.10+ or v2.0+"],"input_types":["LLM client instances (OpenAI, Anthropic, etc.)","Standard LLM API parameters (model, messages, temperature, etc.)"],"output_types":["Validated Pydantic model instances","Streaming iterators of partial model objects"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_10","uri":"capability://automation.workflow.context.window.management.and.token.optimization","name":"context window management and token optimization","description":"Automatically manages context window usage by tracking token counts, truncating schemas and examples to fit within limits, and prioritizing important information. Provides visibility into token usage per request and suggests optimizations (e.g., schema pruning, example removal). Supports custom token counting strategies for different LLM models.","intents":["I want to know how many tokens my structured output request will use","I need to fit my schema and examples within the LLM's context window","I want to optimize token usage without sacrificing output quality"],"best_for":["Teams managing costs for high-volume LLM applications","Builders working with smaller context windows (e.g., mobile models, edge devices)","Applications with strict latency requirements where context size matters"],"limitations":["Token counting is approximate; actual token usage may differ by 5-10% due to tokenizer variations","Automatic schema pruning may remove important information, reducing output quality","Context window limits vary by model; requires manual configuration per model","No built-in strategy for choosing which information to truncate; requires custom logic","Token optimization adds overhead (~10-50ms per request) that may not be worth it for small requests"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Token counting library (tiktoken for OpenAI, custom for others)"],"input_types":["Pydantic model schema","LLM request parameters","Context window size"],"output_types":["Token count estimates","Optimized schema and prompts","Token usage reports"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_11","uri":"capability://automation.workflow.observability.and.debugging.with.request.response.logging","name":"observability and debugging with request/response logging","description":"Logs all LLM requests and responses with structured metadata (model, tokens, latency, validation errors, retries). Integrates with observability platforms (e.g., Langsmith, Arize) to track structured output quality and identify failure patterns. Provides detailed debugging information for validation failures, including which fields failed and why.","intents":["I want to monitor the quality and cost of my structured output requests","I need to debug why the LLM is producing invalid outputs","I want to track retry patterns and identify problematic schemas"],"best_for":["Teams running production LLM applications requiring observability","Developers debugging complex validation failures","Organizations tracking LLM costs and quality metrics"],"limitations":["Logging adds overhead (~5-20ms per request) that compounds with high-volume applications","Sensitive data in requests/responses may be logged; requires careful PII handling","Integration with observability platforms requires additional setup and API keys","Verbose logging can produce large log files; requires log rotation and cleanup","Debugging information is only useful if schemas and error messages are well-designed"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Optional: observability platform (Langsmith, Arize, etc.)"],"input_types":["LLM requests and responses","Validation errors","Retry metadata"],"output_types":["Structured logs","Observability platform events","Debugging reports"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_12","uri":"capability://text.generation.language.prompt.templating.and.dynamic.schema.injection","name":"prompt templating and dynamic schema injection","description":"Provides utilities for embedding Pydantic schemas directly into prompts with automatic formatting and example generation. Supports Jinja2-style templating with schema variables, allowing developers to write prompts that reference model fields and constraints. Automatically generates examples from model defaults and validators.","intents":["I want to include my data model schema in prompts without manual formatting","I need to generate examples from my Pydantic models","I want to write prompts that reference schema fields and constraints"],"best_for":["Developers automating prompt generation from type definitions","Teams maintaining consistency between code schemas and LLM instructions","Builders reducing manual prompt engineering effort"],"limitations":["Template syntax adds complexity; requires learning Jinja2 or similar","Auto-generated examples may not be representative of real data","Schema injection can make prompts verbose and confusing if not carefully formatted","Dynamic schema changes require prompt regeneration; no caching of compiled templates","Template errors can be hard to debug; requires careful validation"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Jinja2 or similar templating library"],"input_types":["Prompt templates with schema variables","Pydantic model definitions"],"output_types":["Formatted prompts with embedded schemas","Generated examples"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_13","uri":"capability://data.processing.analysis.type.coercion.and.automatic.field.transformation","name":"type coercion and automatic field transformation","description":"Automatically coerces LLM-generated values to match Pydantic field types, handling common type mismatches (e.g., string to int, list to single value). Supports custom field serializers and deserializers for complex type transformations. Enables lenient parsing that accepts slightly malformed LLM outputs and transforms them into valid types.","intents":["I want the LLM to return numbers as strings but have them automatically converted to integers","I need to handle cases where the LLM returns a single value instead of a list","I want to apply custom transformations to LLM outputs before validation"],"best_for":["Applications tolerating minor LLM output format variations","Teams wanting to reduce validation failures due to type mismatches","Developers building lenient parsing systems that accept imperfect LLM outputs"],"limitations":["Automatic coercion can mask LLM errors — a number returned as a string might indicate a prompt issue, not a type mismatch","Complex type transformations may lose information (e.g., coercing a list to a single value)","Coercion behavior is implicit and may surprise developers — a string '123' becomes int 123 without explicit conversion code","Pydantic v1 and v2 have different coercion behaviors — behavior may differ across versions"],"requires":["Pydantic 1.0+ or 2.0+","Field type definitions in Pydantic model"],"input_types":["LLM response with potential type mismatches","Pydantic model with field type definitions"],"output_types":["Coerced and transformed values matching field types","Validation errors if coercion fails"],"categories":["data-processing-analysis","type-conversion"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_2","uri":"capability://planning.reasoning.automatic.retry.with.error.feedback.injection","name":"automatic retry with error feedback injection","description":"When validation fails, automatically retries the LLM call with the validation error message injected into the system prompt or user message. Tracks retry count and can apply exponential backoff or custom retry strategies. Extracts specific field-level errors from Pydantic validation and formats them as human-readable feedback that helps the LLM understand what went wrong and self-correct.","intents":["I want the LLM to automatically fix malformed JSON or invalid field values","I need to reduce manual error handling for edge cases in LLM outputs","I want to improve output quality without increasing prompt complexity"],"best_for":["Applications requiring high reliability with minimal manual intervention","Builders prototyping with complex schemas where LLM errors are common","Teams with strict SLA requirements for structured output correctness"],"limitations":["Retry loops consume additional tokens (2-5x multiplier on failure-prone schemas), increasing costs","Max retries must be tuned per schema; too low fails on complex outputs, too high wastes tokens","Error feedback injection can confuse some LLM models if errors are too technical or verbose","No built-in circuit breaker; pathological schemas can cause infinite retry loops if not capped","Retry latency is cumulative; each retry adds full LLM inference time"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","LLM client with retry support or custom retry handler"],"input_types":["Pydantic validation errors","LLM response text","Original LLM request parameters"],"output_types":["Validated Pydantic model instances","Retry metadata (attempt count, errors encountered)"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_3","uri":"capability://data.processing.analysis.streaming.partial.object.construction","name":"streaming partial object construction","description":"Processes streaming LLM responses (token-by-token) and incrementally constructs and validates Pydantic model instances as data arrives. Uses a token buffer and JSON parser to detect complete fields, validate them individually, and yield partial objects to the caller. Enables real-time feedback and progressive rendering without waiting for the full response.","intents":["I want to display LLM results progressively as they stream in, not wait for the full response","I need to validate individual fields as they arrive to catch errors early","I want to build interactive UIs that update in real-time with structured data"],"best_for":["Web applications and chatbots requiring real-time user feedback","Builders creating interactive agents with progressive output rendering","Teams with strict latency requirements where waiting for full responses is unacceptable"],"limitations":["Streaming validation is slower than batch validation due to per-token overhead (~10-50ms per token)","Partial objects may be incomplete; caller must handle None values and optional fields gracefully","JSON parsing on incomplete streams can fail if the LLM produces malformed intermediate JSON","Streaming is not supported by all LLM providers (e.g., some Anthropic models don't stream structured output)","Retry logic is more complex with streaming; must buffer and replay tokens on validation failure"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","LLM client with streaming support (stream=True parameter)"],"input_types":["Streaming LLM response iterator","Pydantic model schema"],"output_types":["Iterator of partial Pydantic model instances","Incremental updates to model fields"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_4","uri":"capability://data.processing.analysis.complex.nested.schema.support.with.recursive.validation","name":"complex nested schema support with recursive validation","description":"Handles arbitrarily nested Pydantic models, lists, unions, and discriminated unions with full recursive validation. Supports forward references, circular type hints, and generic types. Automatically flattens nested schemas into JSON schema format for LLM consumption and reconstructs nested objects from LLM responses with type coercion.","intents":["I need to extract hierarchical data structures (e.g., org charts, parse trees) from LLM outputs","I want to use discriminated unions to handle polymorphic LLM responses","I need to validate deeply nested objects with cross-field constraints"],"best_for":["Applications extracting complex domain models (knowledge graphs, ASTs, hierarchical data)","Teams using advanced Pydantic features (validators, computed fields, discriminated unions)","Builders requiring type-safe polymorphism in LLM outputs"],"limitations":["Deep nesting (>5 levels) can cause context window exhaustion when injecting schemas into prompts","Circular references in type hints require special handling (forward references, model_rebuild) and may confuse some LLMs","Generic types with complex bounds may not serialize to JSON schema correctly, requiring manual schema hints","Validation errors in deeply nested structures produce verbose error messages that can overwhelm the LLM during retries","Performance degrades with very large lists (>1000 items) due to recursive validation overhead"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Support for forward references and model_rebuild() for circular types"],"input_types":["Nested Pydantic model definitions","LLM response JSON with arbitrary nesting"],"output_types":["Fully instantiated nested Pydantic objects","Type-coerced values matching schema constraints"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_5","uri":"capability://text.generation.language.json.schema.generation.and.llm.optimized.formatting","name":"json schema generation and llm-optimized formatting","description":"Automatically converts Pydantic models to JSON schema format and optimizes the schema for LLM consumption by removing verbose type information, adding field descriptions from docstrings, and flattening deeply nested structures. Generates both strict JSON schema (for validation) and LLM-friendly schema (for prompts) with configurable verbosity and example values.","intents":["I want to include my data model schema in prompts without manual JSON schema writing","I need to generate examples and descriptions from my Pydantic models","I want to control how much schema detail is sent to the LLM to save tokens"],"best_for":["Developers automating prompt generation from type definitions","Teams maintaining consistency between code schemas and LLM instructions","Builders optimizing token usage by controlling schema verbosity"],"limitations":["Auto-generated descriptions from docstrings may be incomplete or unclear for complex fields","JSON schema flattening can lose semantic information about field relationships","Very large schemas (>10KB) may exceed LLM context limits or confuse the model","Custom validators and constraints may not translate to JSON schema equivalents, requiring manual hints","Schema generation adds ~10-50ms overhead per model, which compounds with many models"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Field descriptions in docstrings or Pydantic Field(description=...)"],"input_types":["Pydantic BaseModel class definitions"],"output_types":["JSON schema strings","Formatted schema for LLM prompts","Example values and descriptions"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_6","uri":"capability://tool.use.integration.function.calling.with.schema.based.dispatch","name":"function calling with schema-based dispatch","description":"Converts Pydantic models into function calling schemas compatible with OpenAI, Anthropic, and other providers. Automatically generates tool definitions from model fields, handles function argument validation, and dispatches calls to Python functions based on LLM-selected tools. Supports multi-tool scenarios with automatic tool selection and chaining.","intents":["I want to let the LLM call Python functions with validated arguments","I need to build agents that use tools without manual function signature parsing","I want to support multi-step tool chains where one tool's output feeds into another"],"best_for":["Developers building LLM agents with tool use capabilities","Teams creating autonomous systems that interact with APIs and databases","Builders prototyping multi-step workflows with validated function calls"],"limitations":["Function signatures must be expressible as Pydantic models; complex types (callables, custom objects) require wrappers","Tool selection is non-deterministic; LLM may choose wrong tool or refuse to use tools if schema is unclear","No built-in error handling for tool execution failures; caller must implement try-catch and retry logic","Multi-tool scenarios can cause context bloat if tool schemas are large; may require schema pruning","Async function support requires careful handling of event loops and may not work in all environments"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","LLM client with function calling support (OpenAI, Anthropic, etc.)"],"input_types":["Python functions with type hints","Pydantic model definitions","LLM tool call responses"],"output_types":["Validated function arguments as Pydantic models","Function execution results","Tool call metadata (tool name, arguments, result)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_7","uri":"capability://data.processing.analysis.enum.and.union.type.handling.with.llm.aware.serialization","name":"enum and union type handling with llm-aware serialization","description":"Automatically handles Pydantic enums and union types by serializing them to LLM-friendly formats (string literals, discriminated unions) and deserializing LLM responses back to typed Python objects. Supports discriminated unions with automatic type selection based on a discriminator field, enabling polymorphic LLM outputs.","intents":["I want the LLM to choose from a fixed set of options (enums) with type safety","I need to handle polymorphic responses where the type depends on a discriminator field","I want to validate that LLM outputs match one of several expected schemas"],"best_for":["Applications with fixed option sets (e.g., classification, routing decisions)","Teams using discriminated unions for polymorphic domain models","Builders requiring type-safe multi-branch logic based on LLM outputs"],"limitations":["Enum serialization to strings can be ambiguous if enum values are similar (e.g., 'active' vs 'Active')","Discriminated unions require careful schema design; poor discriminator choice can confuse the LLM","Union types with many branches (>10) can cause context bloat and reduce LLM accuracy","Type coercion from string to enum can fail if LLM produces unexpected values; requires fallback handling","Nested unions (unions of unions) are not well-supported and may cause validation errors"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Enum or Union type definitions in Pydantic models"],"input_types":["Pydantic Enum and Union type definitions","LLM response strings or JSON"],"output_types":["Typed Python enum values","Correctly instantiated union type instances"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_8","uri":"capability://safety.moderation.custom.validation.rules.and.field.constraints","name":"custom validation rules and field constraints","description":"Supports Pydantic validators, field constraints (min/max length, regex patterns), and custom validation logic that runs on LLM outputs. Integrates with Pydantic's validator decorators and field constraints, providing detailed error messages when LLM outputs violate constraints. Allows cross-field validation and conditional constraints based on other field values.","intents":["I want to enforce business rules on LLM outputs (e.g., email format, length limits)","I need cross-field validation (e.g., end_date > start_date)","I want custom error messages that help the LLM understand what went wrong"],"best_for":["Applications with strict data quality requirements","Teams enforcing domain-specific constraints on LLM outputs","Builders requiring fine-grained control over validation logic"],"limitations":["Complex validators can be slow; validation overhead scales with validator complexity","Custom validators may not serialize to JSON schema, making them invisible to the LLM during generation","Cross-field validators can produce confusing error messages if not carefully designed","Conditional constraints based on field values can cause retry loops if the LLM doesn't understand the dependency","Validator errors are not always actionable for the LLM; may require manual error message tuning"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Knowledge of Pydantic validator syntax and field constraints"],"input_types":["Pydantic validator decorators","Field constraint definitions","LLM response data"],"output_types":["Validated Pydantic model instances","Detailed validation error messages"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__cap_9","uri":"capability://automation.workflow.batch.processing.with.structured.output","name":"batch processing with structured output","description":"Processes multiple LLM requests in parallel with structured output validation, using async/await patterns and connection pooling to maximize throughput. Validates all responses against the same schema and collects results with error handling for partial failures. Supports batching at the API level (e.g., OpenAI batch API) and application level (concurrent requests).","intents":["I want to process large datasets through an LLM with structured validation","I need to parallelize LLM calls to reduce total latency","I want to handle partial failures gracefully without losing all results"],"best_for":["Data processing pipelines requiring bulk LLM inference","Teams processing large datasets with consistent schema requirements","Builders optimizing for throughput over latency"],"limitations":["Batch processing requires careful error handling; one failed validation doesn't stop the batch, but results may be incomplete","Concurrent requests can hit rate limits; requires backoff and retry logic","Memory usage scales with batch size; very large batches (>10K items) may cause OOM errors","Batch API latency is higher than streaming (minutes to hours for large batches), unsuitable for real-time use","Partial failures are harder to debug; requires detailed logging and error tracking"],"requires":["Python 3.9+","Pydantic v1.10+ or v2.0+","Async support (asyncio or similar)","LLM client with batch API support (OpenAI) or concurrent request support"],"input_types":["List of items to process","Pydantic model schema","LLM request parameters"],"output_types":["List of validated Pydantic model instances","Error tracking and partial result handling"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"instructor__headline","uri":"capability://data.processing.analysis.structured.output.framework.for.llms","name":"structured output framework for llms","description":"Instructor is a library designed to provide structured and validated outputs from large language models using Pydantic models, ensuring reliable data handling and response formatting.","intents":["best structured output framework for LLMs","structured output library for OpenAI","how to validate LLM responses","Pydantic models for LLM outputs","framework for reliable LLM data"],"best_for":["developers needing structured data from LLMs"],"limitations":[],"requires":["Python","Pydantic"],"input_types":["text prompts"],"output_types":["validated structured data"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":57,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Pydantic v1.10+ or v2.0+","OpenAI, Anthropic, or other compatible LLM client library","OpenAI>=1.0.0 OR Anthropic>=0.7.0 OR compatible client library","Token counting library (tiktoken for OpenAI, custom for others)","Optional: observability platform (Langsmith, Arize, etc.)","Jinja2 or similar templating library","Pydantic 1.0+ or 2.0+","Field type definitions in Pydantic model","LLM client with retry support or custom retry handler"],"failure_modes":["Validation overhead adds ~50-200ms per response depending on schema complexity","Retry loops can increase token usage by 2-5x on complex schemas with strict constraints","Nested models with deep recursion (>5 levels) may cause context window exhaustion during retries","No built-in handling for circular references in Pydantic models","Patching approach requires exact knowledge of each provider's API surface; breaking changes in client libraries can break Instructor","Async patching may not work with custom event loops or advanced concurrency patterns","No support for streaming with partial validation on providers that don't support streaming JSON","Patching happens at import time, making it difficult to use multiple versions of the same client","Token counting is approximate; actual token usage may differ by 5-10% due to tokenizer variations","Automatic schema pruning may remove important information, reducing output quality","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.692Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=instructor","compare_url":"https://unfragile.ai/compare?artifact=instructor"}},"signature":"qyofpcrI/7TssXLqHRcoW9KNSBqg+MWb8IBTzFJDY3hQlEj7HXVqO7WtoLqvjZ4f8qCC6QmGY92NFzQu2YgNBw==","signedAt":"2026-06-21T03:29:58.658Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/instructor","artifact":"https://unfragile.ai/instructor","verify":"https://unfragile.ai/api/v1/verify?slug=instructor","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}