Tagging and Extraction - Classification using OpenAI Functions

OpenAI “functions” can be used in LangChain not to trigger external code, but to force large language models to return structured JSON outputs—turning messy text into reliable fields. LangChain’s built-in split into two capabilities—tagging (classification) and extraction (entity/field extraction)—lets developers define a schema up front and then constrain what the model is allowed to output.

For tagging, the workflow starts with a schema describing the labels to predict. A tagging chain is created with an LLM (the transcript references “GPT 3.5 turbo model from the 13th Of June”) and a temperature set to zero. The schema in the example asks for three outputs from each review: sentiment (positive/negative), stars (a rating), and language (English/Spanish/French/German). Under the hood, the model receives both a human prompt template and a functions role payload that includes the schema. A JSON output functions parser then converts the model’s response into structured data automatically.

Initial tests on Amazon reviews from the book “Spare” show what happens when the schema is too loose. One five-star review returns positive sentiment and a stars value of four, but leaves the language field blank. A negative review returns sentiment but omits stars and language. A mixed review returns nothing at all. The takeaway is practical: when the model isn’t sufficiently constrained—especially for required fields—outputs can be incomplete or fail.

Tightening the schema fixes much of the problem. The sentiment field becomes an enum with explicit allowed values (positive, neutral, negative). Stars are constrained to a numeric range (one to five). Language is no longer a free-form guess; it’s an enum limited to specific options (Spanish, English, French, German), and the fields are marked as required. With these constraints, the chain returns complete structured results for the same reviews, including sentiment, stars, and language—now as a Python dictionary. The transcript also demonstrates a Pydantic-based variant (“create tagging chain Pydantic”), where the output conforms to a typed Pydantic class, making it easier to access fields like response.sentiment and response.stars and to pass the object through downstream code.

Extraction works similarly but targets pulling specific fields from longer text, akin to named entity recognition. Using a TechCrunch article about controversy at Reddit, an extraction chain is built with a schema for fields such as person name, startup, news outlet, app name, and month. Only person name and startup are required in the initial setup. The functions role is used to request “information extraction,” and the model can call the function multiple times across the passage, producing a list of JSON objects.

The example highlights common extraction pitfalls: the model may confuse entity types (e.g., treating “Reddit” as a human), misclassify startups vs apps, and miss months. A key mitigation is context management: splitting the article into smaller chunks (e.g., two paragraphs at a time) improves coverage and reduces missed entities. The transcript also notes that adding descriptions to schema fields and using in-context learning examples can further improve accuracy.

Overall, the approach turns unstructured text into structured data using constrained function-style outputs, enabling downstream uses like sentiment analysis, routing different complaint types to different chains, and building knowledge graphs from extracted entities.