ExtractThinker Documentation

ExtractThinker uses Contract classes (inheriting from Pydantic's BaseModel logic) to define the schema for extracted data. You use Field to provide natural language descriptions that guide the LLM on how to interpret and extract specific information. This allows for structured extraction of complex entities like job roles or resumes.

from extract_thinker import Contract
from typing import List, Optional
from pydantic import Field

class RoleContract(Contract):
    company_name: str = Field("Company name")
    years_of_experience: int = Field("Years of experience required. If not mention, calculate with start date and end date")
    is_remote: bool = Field("Is the role remote?")
    country: str = Field("Country of the role")
    city: Optional[str] = Field("City of the role")
    list_of_skills: List[str] = Field("list of strings, e.g [\"5 years experience\", \"3 years in React\", \"Typescript\"]\nMake the lists of skills to be a yes/no list for matching with candidates")

Contracts in ExtractThinker are Pydantic models used to define the specific structure of the data you want to extract. By inheriting from the Contract class, you provide type safety and automatic validation for the extracted information. You can use standard Python type hints and Pydantic's Field to provide descriptions that help the extraction engine understand what each field represents.

from extract_thinker import Contract
from typing import List, Optional
from pydantic import Field

class InvoiceLineItem(Contract):
    description: str = Field(description="Description of the item")
    quantity: int = Field(description="Quantity of items")
    unit_price: float = Field(description="Price per unit")
    amount: float = Field(description="Total amount for line")

class InvoiceContract(Contract):
    invoice_number: str = Field(description="Invoice identifier")
    date: str = Field(description="Invoice date")
    total_amount: float = Field(description="Total invoice amount")
    line_items: List[InvoiceLineItem] = Field(description="List of items in invoice")
    notes: Optional[str] = Field(description="Additional notes", default=None)

The CONCATENATE strategy is used when the content to be extracted or the desired response exceeds the LLM's output context window. It works by splitting the task into chunks, processing them sequentially, and combining the partial responses into a single valid JSON object.

Workflow

1. Initial Request: Sends content to the LLM with the requested structure.
2. Continuation: If the LLM returns a truncated response (finish_reason="length"), the strategy automatically builds a continuation request including the previous partial response for context.
3. Validation: Once the LLM indicates completion (finish_reason="stop"), the strategy combines all parts and validates the final JSON against your specified ResponseModel.

When to use

• Large Context Windows: Best for models like gpt-4o or claude-3-5-sonnet.
• Moderate Document Size: Suitable for documents that are not excessively large (e.g., up to ~500 pages).

Note: For extremely large documents, use the PAGINATE strategy instead.

from extract_thinker import Extractor
from extract_thinker.models.completion_strategy import CompletionStrategy

extractor = Extractor()
extractor.load_llm("gpt-4o")

result = extractor.extract(
    file_path,
    ResponseModel,
    completion_strategy=CompletionStrategy.CONCATENATE
)

ExtractThinker uses Completion Strategies to manage how document content is processed by LLMs, specifically addressing scenarios where document content might exceed the model's context window.

There are three primary strategies available:

1. FORBIDDEN: The default strategy. It prevents processing if the content exceeds the model's context window, ensuring data integrity by not attempting partial or broken extractions.
2. CONCATENATE: Designed for content that exceeds the output capacity but fits within the input context window. It handles large content automatically.
3. PAGINATE: Designed for multi-page documents where the content exceeds both the output and the input context window. This strategy allows for parallel processing and includes mechanisms for conflict resolution between pages.

Choosing the right strategy depends on your document size and whether you need to process the document as a single unit or in parallel chunks.