संरचित आउटपुट के साथ एलएलएम को सीमित करना: ओल्लामा, क्वेन3 & पाइथन या गो

Ollama से संरचित आउटपुट प्राप्त करने के कुछ तरीके

Page content

बड़े भाषा मॉडल (LLMs) शक्तिशाली हैं, लेकिन उत्पादन में हम आमतौर पर मुक्त-रूप पेराग्राफ नहीं चाहते। बजाय इसके, हम प्रत्याशित डेटा चाहते हैं: विशेषताएं, तथ्य, या संरचित वस्तुएं जिन्हें आप एक ऐप में फीड कर सकते हैं। यह है LLM संरचित आउटपुट

कुछ समय पहले Ollama ने संरचित आउटपुट समर्थन पेश किया (घोषणा), जिससे यह संभव हो गया कि एक मॉडल के प्रतिक्रियाओं को एक JSON स्कीमा के साथ सीमित किया जा सके। इससे स्थिर डेटा निकालने के पाइपलाइन खुल जाते हैं जैसे LLM विशेषताओं का कैटलॉगिंग, मॉडल्स का बेंचमार्किंग, या सिस्टम इंटीग्रेशन का स्वचालन।

पंक्तिबद्ध बत्तखें

इस पोस्ट में, हम कवर करेंगे:

  • संरचित आउटपुट क्या है और इसका महत्व
  • LLMs से संरचित आउटपुट प्राप्त करने का सरल तरीका
  • Ollama के नए फीचर का काम कैसे करता है
  • LLM क्षमताओं निकालने के उदाहरण:

संरचित आउटपुट क्या है?

आम तौर पर, LLMs मुक्त पाठ उत्पन्न करते हैं:

“मॉडल X चेन-ऑफ-थॉट के साथ तर्क करने का समर्थन करता है, जिसके पास 200K कॉन्टेक्स्ट विंडो है, और अंग्रेजी, चीनी, और स्पैनिश बोलता है।”

यह पढ़ने योग्य है, लेकिन पार्स करना मुश्किल है।

बजाय इसके, संरचित आउटपुट के साथ हम एक कड़ी स्कीमा मांगते हैं:

{
  "name": "मॉडल X",
  "supports_thinking": true,
  "max_context_tokens": 200000,
  "languages": ["अंग्रेजी", "चीनी", "स्पैनिश"]
}

यह JSON आसानी से वैलिडेट किया जा सकता है, डेटाबेस में स्टोर किया जा सकता है, या एक UI में फीड किया जा सकता है।


LLM से संरचित आउटपुट प्राप्त करने का सरल तरीका

कभी-कभी LLMs समझ जाते हैं कि स्कीमा क्या है और हम LLM से JSON में आउटपुट मांग सकते हैं जिसमें विशेष स्कीमा हो। Qwen3 मॉडल अलिबाबा का है जो तर्क और संरचित प्रतिक्रियाओं के लिए अनुकूलित है। आप इसे स्पष्ट रूप से निर्देश दे सकते हैं कि JSON में प्रतिक्रिया दें

उदाहरण 1: Qwen3 का उपयोग Python में ollama के साथ, JSON स्कीमा के साथ

import json
import ollama

prompt = """
आप एक संरचित डेटा एक्सट्रैक्टर हैं।
केवल JSON लौटाएं।
पाठ: "एलोन मस्क 53 साल के हैं और ऑस्टिन में रहते हैं।"
स्कीमा: { "name": string, "age": int, "city": string }
"""

response = ollama.chat(model="qwen3", messages=[{"role": "user", "content": prompt}])
output = response['message']['content']

# JSON पार्स करें
try:
    data = json.loads(output)
    print(data)
except Exception as e:
    print("JSON पार्स करने में त्रुटि:", e)

आउटपुट:

{"name": "एलोन मस्क", "age": 53, "city": "ऑस्टिन"}

Pydantic के साथ स्कीमा वैलिडेशन लागू करना

गलत आउटपुट से बचने के लिए, आप Python में एक Pydantic स्कीमा के खिलाफ वैलिडेट कर सकते हैं।

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int
    city: str

# मान लीजिए 'output' Qwen3 से JSON स्ट्रिंग है
data = Person.model_validate_json(output)
print(data.name, data.age, data.city)

इससे सुनिश्चित होता है कि आउटपुट अपेक्षित संरचना के अनुसार है।


Ollama का संरचित आउटपुट

Ollama अब आपको format पैरामीटर में एक स्कीमा पास करने की अनुमति देता है। फिर मॉडल केवल उस स्कीमा के अनुसार JSON में प्रतिक्रिया करने के लिए सीमित होता है (दस्तावेज़)।

Python में, आप आमतौर पर अपने स्कीमा को Pydantic के साथ परिभाषित करते हैं और Ollama को उसे JSON स्कीमा के रूप में उपयोग करने देते हैं।


उदाहरण 2: LLM विशेषता मेटाडेटा निकालें

मान लीजिए आपके पास एक LLM की क्षमताओं का वर्णन करने वाला टेक्स्ट स्निपेट है:

“Qwen3 के पास मजबूत बहुभाषी समर्थन है (अंग्रेजी, चीनी, फ्रेंच, स्पैनिश, अरबी)। यह तर्क चरणों की अनुमति देता है (चेन-ऑफ-थॉट)। कॉन्टेक्स्ट विंडो 128K टोकन्स का है।”

आप संरचित डेटा चाहते हैं:

from pydantic import BaseModel
from typing import List
from ollama import chat

class LLMFeatures(BaseModel):
    name: str
    supports_thinking: bool
    max_context_tokens: int
    languages: List[str]

prompt = """
निम्नलिखित वर्णन का विश्लेषण करें और मॉडल की विशेषताओं को केवल JSON में लौटाएं।
मॉडल वर्णन:
'Qwen3 के पास मजबूत बहुभाषी समर्थन है (अंग्रेजी, चीनी, फ्रेंच, स्पैनिश, अरबी)।
यह तर्क चरणों की अनुमति देता है (चेन-ऑफ-थॉट)।
कॉन्टेक्स्ट विंडो 128K टोकन्स का है।'
"""

resp = chat(
    model="qwen3",
    messages=[{"role": "user", "content": prompt}],
    format=LLMFeatures.model_json_schema(),
    options={"temperature": 0},
)

print(resp.message.content)

संभावित आउटपुट:

{
  "name": "Qwen3",
  "supports_thinking": true,
  "max_context_tokens": 128000,
  "languages": ["अंग्रेजी", "चीनी", "फ्रेंच", "स्पैनिश", "अरबी"]
}

उदाहरण 3: कई मॉडल्स की तुलना करें

कई मॉडल्स के वर्णन को फीड करें और संरचित रूप में निकालें:

from typing import List

class ModelComparison(BaseModel):
    models: List[LLMFeatures]

prompt = """
प्रत्येक मॉडल की विशेषताओं को JSON में निकालें।

1. Llama 3.1 तर्क का समर्थन करता है। कॉन्टेक्स्ट विंडो 128K है। भाषाएं: केवल अंग्रेजी।
2. GPT-4 Turbo तर्क का समर्थन करता है। कॉन्टेक्स्ट विंडो 128K है। भाषाएं: अंग्रेजी, जापानी।
3. Qwen3 तर्क का समर्थन करता है। कॉन्टेक्स्ट विंडो 128K है। भाषाएं: अंग्रेजी, चीनी, फ्रेंच, स्पैनिश, अरबी।
"""

resp = chat(
    model="qwen3",
    messages=[{"role": "user", "content": prompt}],
    format=ModelComparison.model_json_schema(),
    options={"temperature": 0},
)

print(resp.message.content)

आउटपुट:

{
  "models": [
    {
      "name": "Llama 3.1",
      "supports_thinking": true,
      "max_context_tokens": 128000,
      "languages": ["अंग्रेजी"]
    },
    {
      "name": "GPT-4 Turbo",
      "supports_thinking": true,
      "max_context_tokens": 128000,
      "languages": ["अंग्रेजी", "जापानी"]
    },
    {
      "name": "Qwen3",
      "supports_thinking": true,
      "max_context_tokens": 128000,
      "languages": ["अंग्रेजी", "चीनी", "फ्रेंच", "स्पैनिश", "अरबी"]
    }
  ]
}

इससे मॉडल्स को उनकी विशेषताओं के आधार पर बेंचमार्क, विज़ुअलाइज़, या फ़िल्टर करना आसान हो जाता है।


उदाहरण 4: स्वचालित रूप से गैप्स पता करें

आप null मानों की अनुमति दे सकते हैं जब कोई फ़ील्ड गायब हो:

from typing import Optional

class FlexibleLLMFeatures(BaseModel):
    name: str
    supports_thinking: Optional[bool]
    max_context_tokens: Optional[int]
    languages: Optional[List[str]]

इससे सुनिश्चित होता है कि आपका स्कीमा तब भी वैलिड रहेगा जब कुछ जानकारी अज्ञात हो।


लाभ, चेतावनियाँ और सर्वोत्तम प्रथाएँ

Ollama (या किसी भी प्रणाली जो इसे समर्थन करती है) के माध्यम से संरचित आउटपुट का उपयोग करने से कई फायदे मिलते हैं - लेकिन कुछ चेतावनियाँ भी हैं।

लाभ

  • मजबूत गारंटी: मॉडल से मांग की जाती है कि वह एक JSON स्कीमा के अनुसार हो, न कि मुक्त-रूप पाठ।
  • आसान पार्सिंग: आप सीधे json.loads कर सकते हैं या Pydantic / Zod के साथ वैलिडेट कर सकते हैं, बजाय रेगेक्स या हीयूरिस्टिक्स के।
  • स्कीमा-आधारित विकास: आप अपने स्कीमा का संस्करण रख सकते हैं, फ़ील्ड्स जोड़ सकते हैं (डिफ़ॉल्ट्स के साथ), और पीछे की संगतता बनाए रख सकते हैं।
  • अंतरोपरता: डाउनस्ट्रीम सिस्टम संरचित डेटा की अपेक्षा करते हैं।
  • निर्धारकता (कम तापमान के साथ बेहतर): जब तापमान कम होता है (उदाहरण के लिए 0), तो मॉडल स्कीमा के साथ कड़ी तरह से चिपकने की संभावना अधिक होती है। Ollama के दस्तावेज़ इसको सिफ़ारिश करते हैं।

चेतावनियाँ और खतरनाक स्थान

  • स्कीमा मिसमैच: मॉडल अभी भी विचलित हो सकता है - उदाहरण के लिए, एक आवश्यक संपत्ति को छोड़ सकता है, कुंजियों को रीऑर्डर कर सकता है, या अतिरिक्त फ़ील्ड्स शामिल कर सकता है। आपको वैलिडेशन की आवश्यकता होगी।
  • जटिल स्कीमास: बहुत गहरे या पुनरावर्ती JSON स्कीमास मॉडल को भ्रमित कर सकते हैं या विफलता का कारण बन सकते हैं।
  • प्रॉम्प्ट में अस्पष्टता: अगर आपका प्रॉम्प्ट अस्पष्ट है, तो मॉडल फ़ील्ड्स या इकाइयों को गलत तरीके से अनुमान लगा सकता है।
  • मॉडल्स के बीच असंगति: कुछ मॉडल्स संरचित बंधनों का पालन करने में बेहतर या खराब हो सकते हैं।
  • टोकन सीमाएँ: स्कीमा स्वयं प्रॉम्प्ट या API कॉल में टोकन लागत जोड़ता है।

सर्वोत्तम प्रथाएँ और टिप्स (Ollama के ब्लॉग + अनुभव से लिए गए)

  • Pydantic (Python) या Zod (JavaScript) का उपयोग करें अपने स्कीमास को परिभाषित करने और JSON स्कीमास को स्वचालित रूप से उत्पन्न करने के लिए। यह मैनुअल त्रुटियों से बचाता है।
  • हमेशा निर्देश शामिल करें जैसे “केवल JSON में प्रतिक्रिया दें” या “किसी भी टिप्पणी या अतिरिक्त पाठ शामिल न करें” अपने प्रॉम्प्ट में।
  • तापमान = 0 (या बहुत कम) का उपयोग करें ताकि यादृच्छिकता को कम किया जा सके और स्कीमा अनुपालन को अधिकतम किया जा सके। Ollama निर्धारकता की सिफ़ारिश करता है।
  • जब JSON पार्सिंग या स्कीमा वैलिडेशन विफल हो तो वैलिडेट करें और संभावित रूप से फॉलबैक करें (उदाहरण के लिए, रीट्राई या क्लीनअप)।
  • एक सरल स्कीमा से शुरू करें, फिर धीरे-धीरे बढ़ाएं। शुरू में जटिल मत बनाएं।
  • उपयोगी लेकिन सीमित त्रुटि निर्देश शामिल करें: उदाहरण के लिए, अगर मॉडल एक आवश्यक फ़ील्ड भर नहीं सकता, तो null लौटाएं बजाय इसे छोड़ने के (अगर आपका स्कीमा इसे अनुमति देता है)।

Go उदाहरण 1: LLM विशेषताओं को निकालना

यहाँ एक सरल Go प्रोग्राम है जो Qwen3 से LLM की विशेषताओं के बारे में संरचित आउटपुट मांगता है।

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"

	"github.com/ollama/ollama/api"
)

type LLMFeatures struct {
	Name             string   `json:"name"`
	SupportsThinking bool     `json:"supports_thinking"`
	MaxContextTokens int      `json:"max_context_tokens"`
	Languages        []string `json:"languages"`
}

func main() {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		log.Fatal(err)
	}

	prompt := `
  निम्नलिखित विवरण का विश्लेषण करें और मॉडल की विशेषताओं को केवल JSON में वापस करें।
  विवरण:
  "Qwen3 के पास मजबूत बहुभाषी समर्थन है (अंग्रेजी, चीनी, फ्रेंच, स्पैनिश, अरबी).
  यह तर्क चरणों की अनुमति देता है (चेन-ऑफ-थॉट).
  कॉन्टेक्स्ट विंडो 128K टोकन्स का है."
  `

	// संरचित आउटपुट के लिए JSON स्कीमा परिभाषित करें
	formatSchema := map[string]any{
		"type": "object",
		"properties": map[string]any{
			"name": map[string]string{
				"type": "string",
			},
			"supports_thinking": map[string]string{
				"type": "boolean",
			},
			"max_context_tokens": map[string]string{
				"type": "integer",
			},
			"languages": map[string]any{
				"type": "array",
				"items": map[string]string{
					"type": "string",
				},
			},
		},
		"required": []string{"name", "supports_thinking", "max_context_tokens", "languages"},
	}

	// स्कीमा को JSON में बदलें
	formatJSON, err := json.Marshal(formatSchema)
	if err != nil {
		log.Fatal("स्कीमा को मार्शल करने में विफल:", err)
	}

	req := &api.GenerateRequest{
		Model:   "qwen3:8b",
		Prompt:  prompt,
		Format:  formatJSON,
		Options: map[string]any{"temperature": 0},
	}

	var features LLMFeatures
	var rawResponse string
	err = client.Generate(context.Background(), req, func(response api.GenerateResponse) error {
		// स्ट्रीमिंग के दौरान सामग्री एकत्र करें
		rawResponse += response.Response

		// केवल तब पार्स करें जब प्रतिक्रिया पूर्ण हो
		if response.Done {
			if err := json.Unmarshal([]byte(rawResponse), &features); err != nil {
				return fmt.Errorf("JSON पार्स एरर: %v", err)
			}
		}
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("पार्स किया गया स्ट्रक्चर: %+v\n", features)
}

इस उदाहरण Go प्रोग्राम को कॉम्पाइल और चलाने के लिए - मान लें कि हमारे पास ollama-struct नामक फोल्डर में main.go फ़ाइल है, हमें इस फोल्डर के अंदर निम्नलिखित कमांड चलाने होंगे:

# मॉड्यूल इनीशियलाइज़ करें
go mod init ollama-struct
# सभी डिपेंडेंसियों को इंस्टॉल करें
go mod tidy
# बिल्ड और एक्सीक्यूट करें
go build -o ollama-struct main.go
./ollama-struct

उदाहरण आउटपुट

पार्स किया गया स्ट्रक्चर: {Name:Qwen3 SupportsThinking:true MaxContextTokens:128000 Languages:[English Chinese French Spanish Arabic]}

Go उदाहरण 2: कई मॉडल की तुलना करना

आप इस कोड को बढ़ा सकते हैं ताकि तुलना के लिए मॉडल की एक सूची निकाल सकें।

  type ModelComparison struct {
		Models []LLMFeatures `json:"models"`
	}

	prompt = `
	निम्नलिखित मॉडल विवरणों से विशेषताएं निकालें और JSON के रूप में वापस करें:

	1. PaLM 2: इस मॉडल के पास सीमित तर्क क्षमताएं हैं और यह बुनियादी भाषा समझ पर केंद्रित है। यह 8,000 टोकन्स की कॉन्टेक्स्ट विंडो का समर्थन करता है। यह मुख्य रूप से केवल अंग्रेजी भाषा का समर्थन करता है।
	2. LLaMA 2: इस मॉडल के पास मध्यम तर्क क्षमताएं हैं और यह कुछ तार्किक कार्यों को संभाल सकता है। यह अपनी कॉन्टेक्स्ट में 4,000 टोकन्स तक प्रोसेस कर सकता है। यह अंग्रेजी, स्पैनिश, और इटालियन भाषाओं का समर्थन करता है।
	3. Codex: इस मॉडल के पास प्रोग्रामिंग और कोड विश्लेषण के लिए मजबूत तर्क क्षमताएं हैं। इसके पास 16,000 टोकन्स की कॉन्टेक्स्ट विंडो है। यह अंग्रेजी, Python, JavaScript, और Java भाषाओं का समर्थन करता है।

	एक JSON ऑब्जेक्ट वापस करें जिसमें सभी मॉडल्स को शामिल करने वाला "models" एरे है।
	`

	// मॉडल तुलना के लिए JSON स्कीमा परिभाषित करें
	comparisonSchema := map[string]any{
		"type": "object",
		"properties": map[string]any{
			"models": map[string]any{
				"type": "array",
				"items": map[string]any{
					"type": "object",
					"properties": map[string]any{
						"name": map[string]string{
							"type": "string",
						},
						"supports_thinking": map[string]string{
							"type": "boolean",
						},
						"max_context_tokens": map[string]string{
							"type": "integer",
						},
						"languages": map[string]any{
							"type": "array",
							"items": map[string]string{
								"type": "string",
							},
						},
					},
					"required": []string{"name", "supports_thinking", "max_context_tokens", "languages"},
				},
			},
		},
		"required": []string{"models"},
	}

	// स्कीमा को JSON में बदलें
	comparisonFormatJSON, err := json.Marshal(comparisonSchema)
	if err != nil {
		log.Fatal("तुलना स्कीमा को मार्शल करने में विफल:", err)
	}

	req = &api.GenerateRequest{
		Model:   "qwen3:8b",
		Prompt:  prompt,
		Format:  comparisonFormatJSON,
		Options: map[string]any{"temperature": 0},
	}

	var comp ModelComparison
	var comparisonResponse string
	err = client.Generate(context.Background(), req, func(response api.GenerateResponse) error {
		// स्ट्रीमिंग के दौरान सामग्री एकत्र करें
		comparisonResponse += response.Response

		// केवल तब पार्स करें जब प्रतिक्रिया पूर्ण हो
		if response.Done {
			if err := json.Unmarshal([]byte(comparisonResponse), &comp); err != nil {
				return fmt.Errorf("JSON पार्स एरर: %v", err)
			}
		}
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}

	for _, m := range comp.Models {
		fmt.Printf("%s: Context=%d, Languages=%v\n", m.Name, m.MaxContextTokens, m.Languages)
	}

उदाहरण आउटपुट

PaLM 2: Context=8000, Languages=[English]
LLaMA 2: Context=4000, Languages=[English Spanish Italian]
Codex: Context=16000, Languages=[English Python JavaScript Java]

दरअसल, इन उदाहरणों में qwen3:4b भी अच्छी तरह से काम करता है, जैसे qwen3:8b।

Go डेवलपर्स के लिए सर्वोत्तम प्रथाएं

  • तापमान को 0 पर सेट करें अधिकतम स्कीमा अनुपालन के लिए।
  • json.Unmarshal के साथ वैलिडेशन करें और अगर पार्सिंग विफल हो तो फॉलबैक करें।
  • स्कीमाओं को सरल रखें - गहरे नेटेड या रिकर्सिव JSON स्ट्रक्चर समस्याएं पैदा कर सकते हैं।
  • ऑप्शनल फील्ड्स की अनुमति दें (Go स्ट्रक्चर टैग्स में omitempty का उपयोग करें) अगर आप गायब डेटा की उम्मीद करते हैं।
  • रीट्राइज़ जोड़ें अगर मॉडल कभी-कभी अमान्य JSON उत्पन्न करता है।

पूर्ण उदाहरण - LLM स्पेस के साथ चार्ट बनाना (चरण-दर-चरण: संरचित JSON से तुलना तालिकाओं तक)

llm-chart

  1. आप जिस डेटा चाहते हैं उसके लिए एक स्कीमा परिभाषित करें

Pydantic का उपयोग करें ताकि आप (a) Ollama के लिए एक JSON स्कीमा उत्पन्न कर सकें और (b) मॉडल की प्रतिक्रिया की वैलिडेशन कर सकें।

from pydantic import BaseModel
from typing import List, Optional

class LLMFeatures(BaseModel):
    name: str
    supports_thinking: bool
    max_context_tokens: int
    languages: List[str]
  1. केवल उस शेप में JSON वापस करने के लिए Ollama से पूछें

format= में स्कीमा पास करें और निर्धारण के लिए तापमान कम करें।

from ollama import chat

prompt = """
हर मॉडल के लिए विशेषताएं निकालें। केवल स्कीमा के साथ मिलान करने वाला JSON वापस करें।
1) Qwen3 चेन-ऑफ-थॉट का समर्थन करता है; 128K कॉन्टेक्स्ट; अंग्रेजी, चीनी, फ्रेंच, स्पैनिश, अरबी।
2) Llama 3.1 चेन-ऑफ-थॉट का समर्थन करता है; 128K कॉन्टेक्स्ट; अंग्रेजी।
3) GPT-4 Turbo चेन-ऑफ-थॉट का समर्थन करता है; 128K कॉन्टेक्स्ट; अंग्रेजी, जापानी।
"""

resp = chat(
    model="qwen3",
    messages=[{"role": "user", "content": prompt}],
    format={"type": "array", "items": LLMFeatures.model_json_schema()},
    options={"temperature": 0}
)

raw_json = resp.message.content  # JSON LLMFeatures की सूची
  1. वैलिडेट और नॉर्मलाइज़ करें

हमेशा उत्पादन में उपयोग करने से पहले वैलिडेट करें।

from pydantic import TypeAdapter

adapter = TypeAdapter(list[LLMFeatures])
models = adapter.validate_json(raw_json)  # -> list[LLMFeatures]
  1. एक तुलना तालिका बनाएं (pandas)

अपनी वैलिडेटेड ऑब्जेक्ट्स को एक DataFrame में बदलें जिसे आप सॉर्ट/फिल्टर और एक्सपोर्ट कर सकते हैं।

import pandas as pd

df = pd.DataFrame([m.model_dump() for m in models])
df["languages_count"] = df["languages"].apply(len)
df["languages"] = df["languages"].apply(lambda xs: ", ".join(xs))

# पठनीयता के लिए कॉलम्स को रीऑर्डर करें
df = df[["name", "supports_thinking", "max_context_tokens", "languages_count", "languages"]]

# आगे के उपयोग के लिए CSV के रूप में सेव करें
df.to_csv("llm_feature_comparison.csv", index=False)
  1. (ऑप्शनल) तेज़ दृश्य

सरल चार्ट आपको मॉडल्स के बीच अंतरों को तेज़ी से देखने में मदद करते हैं।

import matplotlib.pyplot as plt

plt.figure()
plt.bar(df["name"], df["max_context_tokens"])
plt.title("मॉडल द्वारा अधिकतम कॉन्टेक्स्ट विंडो (टोकन्स)")
plt.xlabel("मॉडल")
plt.ylabel("अधिकतम कॉन्टेक्स्ट टोकन्स")
plt.xticks(rotation=20, ha="right")
plt.tight_layout()
plt.savefig("max_context_window.png")

TL;DR

Ollama के नए संरचित आउटपुट समर्थन के साथ, आप LLMs को केवल चैटबॉट्स के रूप में नहीं बल्कि डेटा एक्सट्रैक्शन इंजन के रूप में भी उपयोग कर सकते हैं।

उपरोक्त उदाहरणों ने दिखाया कि कैसे LLM विशेषताओं जैसे तर्क समर्थन, कॉन्टेक्स्ट विंडो आकार, और समर्थित भाषाएं जैसे संरचित मेटाडेटा को स्वचालित रूप से निकालें - जो अन्यथा ब्रिटल पार्सिंग की आवश्यकता होती।

चाहे आप एक LLM मॉडल कैटलॉग, एक इवैलुएशन डैशबोर्ड, या एक AI-पावरड रिसर्च असिस्टेंट बन रहे हों, संरचित आउटपुट्स को इंटीग्रेट करना सुलभ, विश्वसनीय और उत्पादन-तैयार बनाते हैं।

उपयोगी लिंक्स