> ## Documentation Index
> Fetch the complete documentation index at: https://langwatch.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Lingua Language Detection

> This evaluator detects the language of the input and output text to check for example if the generated answer is in the same language as the prompt,
or if it's in a specific expected language.



## OpenAPI

````yaml post /lingua/language_detection/evaluate
openapi: 3.1.0
info:
  title: LangEvals API
  version: 1.0.0
  description: API for LangEvals evaluators
servers:
  - url: https://app.langwatch.ai/api/evaluations
    description: Production server
security:
  - api_key: []
paths:
  /lingua/language_detection/evaluate:
    post:
      summary: Lingua Language Detection
      description: >-
        This evaluator detects the language of the input and output text to
        check for example if the generated answer is in the same language as the
        prompt,

        or if it's in a specific expected language.
      operationId: lingua_language_detection_evaluate
      requestBody:
        content:
          application/json:
            schema:
              allOf:
                - $ref: '#/components/schemas/lingua_language_detectionRequest'
                - type: object
                  properties:
                    settings:
                      $ref: '#/components/schemas/lingua_language_detectionSettings'
        required: true
      responses:
        '200':
          description: Successful evaluation
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/EvaluationResult'
        '400':
          description: Bad request
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
      x-codeSamples:
        - lang: python
          label: Experiment
          source: |
            import langwatch

            df = langwatch.datasets.get_dataset("dataset-id").to_pandas()

            experiment = langwatch.experiment.init("my-experiment")

            for index, row in experiment.loop(df.iterrows()):
                # your execution code here
                experiment.evaluate(
                    "lingua/language_detection",
                    index=index,
                    data={
                        "output": output,
                        "input": row["input"],
                    },
                    settings={}
                )
        - lang: python
          label: Online Evaluation
          source: |-
            import langwatch

            @langwatch.span()
            def my_llm_step():
                ... # your existing code
                result = langwatch.evaluation.evaluate(
                    "lingua/language_detection",
                    name="My Lingua Language Detection Check",
                    data={
                        "output": "",
                        "input": "",
                    },
                    settings={},
                )
                print(result)
        - lang: typescript
          label: Experiment
          source: >-
            import { LangWatch } from "langwatch";


            const langwatch = new LangWatch();


            // Fetch dataset from LangWatch

            const dataset = await langwatch.datasets.get("your-dataset-slug");


            const experiment = await
            langwatch.experiments.init("my-experiment");


            await experiment.run(
              dataset.entries.map((e) => e.entry),
              async ({ item, index }) => {
                // Run your LLM/agent
                const output = await myLLM(item.input);

                // Evaluate the output
                await experiment.evaluate("lingua/language_detection", {
                  index,
                  data: {
                    output: output,
                    input: item.input,
                  },
                });
              },
              { concurrency: 4 }
            );
        - lang: typescript
          label: Online Evaluation
          source: |-
            import { LangWatch } from "langwatch";

            const langwatch = new LangWatch();

            async function myLLMStep(input: string): Promise<string> {
              // ... your existing code

              // Call the evaluator
              const result = await langwatch.evaluations.evaluate("lingua/language_detection", {
                name: "my-evaluation",
                data: {
                  output: "", // your output value
                  input: "", // your input value
                },
                settings: {},
              });

              console.log(result);
              return result;
            }
components:
  schemas:
    lingua_language_detectionRequest:
      type: object
      properties:
        trace_id:
          type: string
          description: Optional trace ID to associate this evaluation with a trace
        data:
          type: object
          properties:
            output:
              type: string
              description: The output/response text to evaluate
            input:
              type: string
              description: The input text to evaluate
          required:
            - output
      required:
        - data
    lingua_language_detectionSettings:
      type: object
      properties:
        check_for:
          description: What should be checked
          type: string
          default: input_matches_output
        expected_language:
          description: The specific language that the output is expected to be
          type: string
        min_words:
          description: >-
            Minimum number of words to check, as the language detection can be
            unreliable for very short texts. Inputs shorter than the minimum
            will be skipped.
          type: number
          default: 7
        threshold:
          description: >-
            Minimum confidence threshold for the language detection. If the
            confidence is lower than this, the evaluation will be skipped.
          type: number
          default: 0.25
    EvaluationResult:
      type: object
      properties:
        status:
          type: string
          enum:
            - processed
            - skipped
            - error
        score:
          type: number
          description: Numeric score from the evaluation
        passed:
          type: boolean
          description: Whether the evaluation passed
        label:
          type: string
          description: Label assigned by the evaluation
        details:
          type: string
          description: Additional details about the evaluation
        cost:
          type: object
          properties:
            currency:
              type: string
            amount:
              type: number
  securitySchemes:
    api_key:
      type: apiKey
      in: header
      name: X-Auth-Token
      description: API key for authentication

````