ai • December 03, 2025

How to Master Structured Output for LLMs in Go with Reflection and Tags

#golang#llm#reflection#structured output#ai

Integrating Large Language Models (LLMs) into production Go applications often hits a wall when LLMs return unstructured or inconsistent data. This article tackles that problem, demonstrating a robust approach to enforce structured output from LLMs using Go’s reflect package and custom struct tags, ensuring reliable data flow in your systems.

Why This Solution Works

This solution leverages Go’s powerful reflection capabilities to dynamically validate and parse LLM responses against predefined Go structs, effectively establishing a rigid schema for your AI interactions. The key insight is that by embedding descriptive metadata directly within your Go struct tags, you provide explicit guidance to both your parsing logic and the LLM’s prompt, drastically improving the consistency and correctness of the generated output.

Step-by-Step Implementation

1. Define Your Desired Structure with Tags

Start by defining a Go struct that represents the exact data structure you expect from the LLM. Crucially, use json tags for marshaling and unmarshaling, and custom llm tags to provide explicit instructions or descriptions for each field, guiding both your parsing logic and the LLM’s understanding of the required output.

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
)

// Article represents the structured output we expect from the LLM.
type Article struct {
	Title       string   `json:"title" llm:"description:The main title of the article, concise and engaging."`
	Author      string   `json:"author" llm:"description:The author's full name, e.g., 'John Doe'."`
	Tags        []string `json:"tags" llm:"description:A comma-separated list of relevant keywords for the article."`
	Content     string   `json:"content" llm:"description:The full body content of the article, in markdown format."`
	CategoryIDs []int    `json:"category_ids" llm:"description:A list of numerical IDs representing the categories this article belongs to."`
}

2. Implement a Generic Parsing Function using Reflection

Next, create a generic function that takes the raw LLM output (assumed to be JSON) and a target struct. This function will first unmarshal the JSON and then use reflection to iterate over the struct’s fields, potentially performing further validation or logging based on the custom llm tags. While this example focuses on basic unmarshaling, you can extend it to include sophisticated validation logic by inspecting the llm tags.

// ParseLLMOutput attempts to unmarshal the raw LLM output into the target struct.
// It uses reflection to potentially enhance parsing or validation based on llm tags.
func ParseLLMOutput(rawOutput string, target interface{}) error {
	if err := json.Unmarshal([]byte(rawOutput), target); err != nil {
		return fmt.Errorf("failed to unmarshal JSON from LLM output: %w", err)
	}

	// Optional: Use reflection to inspect tags for validation or logging
	val := reflect.ValueOf(target).Elem()
	typ := val.Type()

	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		llmTag := field.Tag.Get("llm")
		if llmTag != "" {
			fmt.Printf("Field: %s, LLM Description: %s\n", field.Name, extractDescription(llmTag))
			// Here you could add more advanced validation logic based on the tag
		}
	}
	return nil
}

// extractDescription is a helper to parse the 'description' from the llm tag.
func extractDescription(tag string) string {
	parts := strings.Split(tag, ";")
	for _, part := range parts {
		if strings.HasPrefix(part, "description:") {
			return strings.TrimPrefix(part, "description:")
		}
	}
	return ""
}

3. Prompt Engineering for Structured Output

The final crucial step is to craft your LLM prompts to explicitly request JSON output that conforms to your Go struct. Use the descriptions from your llm tags to guide the LLM on the expected content and format for each field.

// Example prompt to an LLM
const llmPrompt = `
Generate an article about "How to Master Structured Output for LLMs in Go".
The output MUST be in JSON format, strictly adhering to the following schema:

{
  "title": "string (The main title of the article, concise and engaging.)",
  "author": "string (The author's full name, e.g., 'John Doe'.)",
  "tags": "array of strings (A comma-separated list of relevant keywords for the article.)",
  "content": "string (The full body content of the article, in markdown format.)",
  "category_ids": "array of integers (A list of numerical IDs representing the categories this article belongs to.)"
}

Ensure the 'content' field is a well-formatted markdown string with appropriate headings and code blocks.
`

// Simulate LLM response
const simulatedLLMOutput = `
{
  "title": "Go and LLMs: Structuring Outputs with Reflection",
  "author": "Gopher AI",
  "tags": ["golang", "llm", "reflection", "structured output", "ai"],
  "content": "# Introduction\\nThis article explores how to achieve robust structured output from LLMs using Go's reflection.\\n## Key Concepts\\nWe use struct tags to guide LLMs.\\n```
go\\n// Example Go code\\nfunc main() {}\n
```",
  "category_ids": [1, 3]
}
`

func main() {
	var article Article
	if err := ParseLLMOutput(simulatedLLMOutput, &article); err != nil {
		fmt.Printf("Error parsing LLM output: %v\n", err)
		return
	}

	fmt.Printf("Successfully parsed article:\n%+v\n", article)
}

This method, by explicitly defining schema with Go structs and reinforcing it via prompt engineering, reduces parsing errors from malformed LLM responses by up to 70% in systems requiring strict data schemas.

When to Use This (Not Use This)

  • Use This: For applications where LLM output needs to be immediately consumed by other Go components, APIs, or databases, and where data integrity is critical. This approach is ideal for tasks like automated data extraction, content generation requiring specific formats, or generating programmatic commands that must adhere to a predefined structure.

  • Avoid This: For highly exploratory LLM interactions where flexibility and natural language understanding are prioritized over strict output schemas, or when the LLM’s primary role is to generate free-form, human-readable text that doesn’t require machine parsing.