구조화된 출력으로 LLM 제한: Ollama, Qwen3 및 Python 또는 Go

{
  "name": "Model X",
  "supports_thinking": true,
  "max_context_tokens": 200000,
  "languages": ["English", "Chinese", "Spanish"]
}

import json
import ollama

prompt = """
구조화된 데이터 추출기입니다.
JSON만 반환합니다.
텍스트: "Elon Musk는 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": "Elon Musk", "age": 53, "city": "Austin"}

from pydantic import BaseModel

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

# Qwen3에서 얻은 JSON 문자열이 'output'이라고 가정
data = Person.model_validate_json(output)
print(data.name, data.age, data.city)

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": ["English", "Chinese", "French", "Spanish", "Arabic"]
}

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": ["English"]
    },
    {
      "name": "GPT-4 Turbo",
      "supports_thinking": true,
      "max_context_tokens": 128000,
      "languages": ["English", "Japanese"]
    },
    {
      "name": "Qwen3",
      "supports_thinking": true,
      "max_context_tokens": 128000,
      "languages": ["English", "Chinese", "French", "Spanish", "Arabic"]
    }
  ]
}

from typing import Optional

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

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("JSON 스키마 변환 실패:", 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 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]}

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

prompt = `
다음 모델 설명에서 기능을 추출하고 JSON 형식으로 반환하세요:

1. PaLM 2: 이 모델은 추론 능력이 제한되어 있으며, 기본 언어 이해에 집중합니다. 컨텍스트 창은 8,000 토큰입니다. 주로 영어만 지원합니다.
2. LLaMA 2: 이 모델은 중간 정도의 추론 능력을 가지며, 일부 논리 작업을 처리할 수 있습니다. 컨텍스트는 최대 4,000 토큰입니다. 영어, 스페인어, 이탈리아어를 지원합니다.
3. Codex: 이 모델은 프로그래밍 및 코드 분석에 특화된 강력한 추론 능력을 가집니다. 컨텍스트 창은 16,000 토큰입니다. 영어, 파이썬, 자바스크립트, 자바를 지원합니다.

"models" 배열을 포함하는 JSON 객체를 반환하세요.
`

// 모델 비교를 위한 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]

from pydantic import BaseModel
from typing import List, Optional

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

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 목록

from pydantic import TypeAdapter

adapter = TypeAdapter(list[LLMFeatures])
models = adapter.validate_json(raw_json)  # -> list[LLMFeatures]

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)

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")