docs/tutorials/classification/

[giscus[bot]]

docs/tutorials/classification/

Open In Colab

https://python.langchain.com/docs/tutorials/classification/

[2980897531]

But the restrictions have not taken effect in this sentence“Classification(sentiment='enojado', aggressiveness=8, language='es')”

[kavehpouran]

Good observation. I was not able to reproduce this behaviour though - the scoring restriction took effect when I ran the code.

[RanjitSolomon]

Is this specific to OpenAI? Is it possible to get Ollama -llama3 version.
Getting an error,
aggressiveness
Input should be a valid integer [type=int_type, input_value=None, input_type=NoneType

[gudata]

I would also want to know why the examples do not include the ollama?

[mic-de-stefano]

This tutorial does not work either with Gemini (1.5, flash or pro) or with any HuggingFace model.
With HuggingFace, it crashes at the frist .with_structured_output invocation. With Gemini, it crashes when we use enums into the Classification specification.

[hczs]

Same problem!
Do you have any good solutions, thank you

[PK109]

I do not think you can make something around that for now. When on purpose I have placed code

    aggressiveness: **int** = Field(
        description="describes how aggressive the statement is, the higher the number the more aggressive",
        enum=[ **str**(x) for x in range(1,10,2)]
    )

I have received error:
InvalidArgument: 400 * GenerateContentRequest.tools[0].function_declarations[0].parameters.properties[aggressiveness].enum: only allowed for STRING type

[NihilDigit]

I managed to make structured output work with the Deepseek model, and I think this approach may work for other non-OpenAI models as well. The main concept is to include our output requirements directly in the prompt and manually parse the JSON response into a BaseModel. https://github.com/NihilDigit/DeepSeek-Structured-Output-for-LangChain

[Alfadhils]

Thanks, this works great with local models too! Just a heads-up—since we're manually parsing the JSON, the model needs to return strictly valid JSON. I had to tweak the prompt a bit and use a more capable model to get consistent JSON output.

[IlyaUmanets]

FYI, It works perfectly with just English sentences. I added one more property

spell_check: bool = Field(
    ...,
    description="describes if there is any typos or grammar issues in the passage",
    enum=[True, False]
)

and it returned true If I passed an input like this "I hate youu" in English, and it returned false if I passed the same message but in Ukrainian.

[yosephberhanu]

I needed to make the Classification fields optional for this work

from typing import Optional

class Classification(BaseModel):
    sentiment: Optional[str] = Field(default=None, description="The sentiment of the text")
    aggressiveness: Optional[int] = Field(default=-1, description="How aggressive the text is on a scale from 1 to 10" )
    language: Optional[str] = Field(default=None, description="The language the text is written in")

[hantconny]

I use Groq and it gives the expected output

remove the first llm chat model statement

llm = init_chat_model("llama3-8b-8192", model_provider="groq")

change the second llm statement from ChatOpenAI to ChatGroq, they both extend from BaseChatModel

llm = ChatGroq().with_structured_output(
    Classification
)

complete version below:

# -*- coding:utf-8 -*-
import os

from langchain_core.prompts import ChatPromptTemplate
from langchain_groq import ChatGroq
from pydantic import BaseModel, Field

os.environ["GROQ_API_KEY"] = "yout api key"


tagging_prompt = ChatPromptTemplate.from_template(
    """
Extract the desired information from the following passage.

Only extract the properties mentioned in the 'Classification' function.

Passage:
{input}
"""
)


# schema
class Classification(BaseModel):
    sentiment: str = Field(description="The sentiment of the text")
    aggressiveness: int = Field(
        description="How aggressive the text is on a scale from 1 to 10"
    )
    language: str = Field(description="The language the text is written in")


# LLM
llm = ChatGroq().with_structured_output(
    Classification
)

inp = "Estoy increiblemente contento de haberte conocido! Creo que seremos muy buenos amigos!"
prompt = tagging_prompt.invoke({"input": inp})
response = llm.invoke(prompt)

print(response.model_dump_json())

output:

{"sentiment":"positive","aggressiveness":1,"language":"Spanish"}

[hczs]

When i use enum of pydantic BaseModel Field, it has warning:
Unexpected argument(s)
Possible callees:
Field(default: ellipsis, *, alias: str | None = _Unset, alias_priority: int | None = _Unset,...

And i run the code, it has some error:
TypeError Traceback (most recent call last)
/usr/local/lib/python3.11/dist-packages/proto/marshal/rules/message.py in to_proto(self, value)
35 # Try the fast path first.
---> 36 return self._descriptor(**value)
37 except (TypeError, ValueError, AttributeError) as ex:

TypeError: Parameter to CopyFrom() must be instance of same class: expected <class 'Schema'> got <class 'dict'>.

During handling of the above exception, another exception occurred:

TypeError Traceback (most recent call last)
15 frames
TypeError: bad argument type for built-in operation

During handling of the above exception, another exception occurred:

TypeError Traceback (most recent call last)
/usr/local/lib/python3.11/dist-packages/proto/message.py in init(self, mapping, ignore_unknown_fields, **kwargs)
732
733 # Create the internal protocol buffer.
--> 734 super().setattr("_pb", self._meta.pb(**params))
735
736 def _get_pb_type_from_key(self, key):

TypeError: bad argument type for built-in operation

some lib version:
langchain 0.3.21
langchain-community 0.3.20
langchain-core 0.3.47
langchain-google-genai 2.1.1
langchain-google-vertexai 2.0.16
langchain-mongodb 0.5.0
langchain-text-splitters 0.3.7
pydantic 2.10.6
pydantic_core 2.27.2
pydantic-settings 2.8.1

[sunny-zhang-98]

I have the same problem, it seems that it can only be changed to use pattern, but this should not be able to give the use of langchain

[EduardoAndreu]

Hi All,

For those trying to follow this tutorial using Gemini, here's the full code. I encounter two things to watch out for:

1 - Pydantic's Field(..., enum=[...]) is not valid for specifying enums in Pydantic v1 or v2.
2 - The Gemini API (and the LangChain wrapper) currently have limited support for Pydantic models with non-string enums and certain field types.

import getpass
import os
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from enum import Enum
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.prompts import ChatPromptTemplate


def main():
    # Load environment variables
    load_dotenv()
    if not os.environ.get("GOOGLE_API_KEY"):
        os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter your Google API key: ")

    # Initialize Chat Model
    from langchain.chat_models import init_chat_model

    # Specify a Pydantic model
    tagging_prompt = ChatPromptTemplate.from_template(
        """
        Extract the desired information from the following passage. 

        Only extract the properties mentioned in the 'Classification' function.

        Passage:
        {input}
        """
    )

    class SentimentEnum(str, Enum):
        happy = "happy"
        neutral = "neutral"
        sad = "sad"

    class AggressivenessEnum(str, Enum):
        one = "1"
        two = "2"
        three = "3"
        four = "4"
        five = "5"

    class LanguageEnum(str, Enum):
        spanish = "spanish"
        english = "english"
        french = "french"
        german = "german"
        italian = "italian"

    class Classification(BaseModel):
        sentiment: SentimentEnum
        aggressiveness: AggressivenessEnum = Field(
            ..., description="describes how aggressive the statement is, the higher the number the more aggressive"
        )
        language: LanguageEnum

    # Structured LLM output
    llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash").with_structured_output(
        Classification
    )

    # Run
    inp = "Quieres tomarte un cafe? Hay una nueva cafeteria que tiene muy buena pinta."
    prompt = tagging_prompt.invoke({"input": inp})
    result = llm.invoke(prompt)
    print(result)


if __name__ == "__main__":
    main()

Output:

sentiment=<SentimentEnum.happy: 'happy'> aggressiveness=<AggressivenessEnum.one: '1'> language=<LanguageEnum.spanish: 'spanish'>

Just to say too a huge thank you to those putting these tutorials together! They are incredibly helpful and well structured.

Ed