GEO Optimizer: Make Your Content Visible to AI Engines

A pluggable framework for GEO (Generative Engine Optimization) in Go. Built-in strategies for common use cases, with full support for custom strategy registration.

Why this framework?

• 🧩 Pluggable Architecture - Register your own optimization strategies or use built-in ones
• 📦 5 Built-in Strategies - Structure, Schema, AnswerFirst, Authority, FAQ ready to use
• 🔌 Easy Extension - Implement the Strategy interface to add custom logic
• 🎯 Composable - Mix and match strategies for different optimization needs

Features

• Multi-Strategy Optimization: 5 built-in optimization strategies that can be combined
• LLM Abstraction: Clean interface supporting multiple LLM providers (GLM, extensible to others)
• Content Scoring: Rule-based GEO quality scoring system
• AI Platform Presets: Pre-configured preferences for ChatGPT, Perplexity, Google AI, and Claude
• Schema Markup: Automatic JSON-LD structured data generation
• Enterprise Ready: Multi-tenant architecture with enterprise isolation

Installation

go get github.com/Lin-Jiong-HDU/geo-optimizer

Quick Start

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Lin-Jiong-HDU/geo-optimizer/pkg/llm"
    "github.com/Lin-Jiong-HDU/geo-optimizer/pkg/models"
    "github.com/Lin-Jiong-HDU/geo-optimizer/pkg/optimizer"
)

func main() {
    // 1. Create LLM client
    client, err := llm.NewClient(llm.Config{
        Provider: llm.ProviderGLM,
        APIKey:   "your-api-key",
        Model:    "glm-4.7",
    })
    if err != nil {
        log.Fatal(err)
    }

    // 2. Create optimizer
    opt := optimizer.New(client)

    // 3. Build request
    req := &models.OptimizationRequest{
        Content: "Your content here...",
        Title:   "Content Title",
        Enterprise: models.EnterpriseInfo{
            CompanyName: "Your Company",
            ProductName: "Your Product",
        },
        Strategies: []models.StrategyType{
            models.StrategyStructure,
            models.StrategySchema,
        },
    }

    // 4. Execute optimization
    resp, err := opt.Optimize(context.Background(), req)
    if err != nil {
        log.Fatal(err)
    }

    // 5. Use results
    fmt.Printf("Score: %.2f -> %.2f\n", resp.ScoreBefore, resp.ScoreAfter)
    fmt.Println(resp.OptimizedContent)
}

Optimization Strategies

Built-in Strategies

Strategy	Description
StrategyStructure	Adds clear heading hierarchy, bullet points, and organized sections
StrategySchema	Generates JSON-LD structured data markup
StrategyAnswerFirst	Moves key conclusions to the beginning
StrategyAuthority	Enhances with citations, sources, and credentials
StrategyFAQ	Generates FAQ sections for common queries

Register Custom Strategies

The framework is designed for extensibility. Implement the Strategy interface to add your own optimization logic:

import strategiespkg "github.com/Lin-Jiong-HDU/geo-optimizer/pkg/optimizer/strategies"

// Define your custom strategy
type SEOStrategy struct {
    *strategiespkg.BaseStrategy
    keywords []string
}

func NewSEOStrategy(keywords []string) *SEOStrategy {
    return &SEOStrategy{
        BaseStrategy: strategiespkg.NewBaseStrategy("seo", "SEO Optimization"),
        keywords:     keywords,
    }
}

// Implement the Strategy interface
func (s *SEOStrategy) Validate(req *models.OptimizationRequest) bool {
    return len(s.keywords) > 0
}

func (s *SEOStrategy) BuildPrompt(req *models.OptimizationRequest) string {
    return fmt.Sprintf("Optimize for keywords: %v\n\n%s", s.keywords, req.Content)
}

// Register and use your strategy
func main() {
    opt := optimizer.New(client)

    // Register custom strategy
    opt.RegisterStrategy(NewSEOStrategy([]string{"cloud", "AI", "optimization"}))

    // Use it alongside built-in strategies
    req := &models.OptimizationRequest{
        Content:    "...",
        Strategies: []models.StrategyType{"seo", models.StrategyStructure},
    }

    resp, _ := opt.Optimize(ctx, req)
}

Strategy Interface

type Strategy interface {
    Name() string
    Type() models.StrategyType
    Validate(req *models.OptimizationRequest) bool
    Preprocess(content string, req *models.OptimizationRequest) string
    Postprocess(content string, req *models.OptimizationRequest) string
    BuildPrompt(req *models.OptimizationRequest) string
}

Architecture

pkg/
├── optimizer/         # Core optimization engine
│   └── strategies/    # Individual strategy implementations
├── llm/               # LLM abstraction layer
│   └── prompts/       # Prompt templates and builders
├── models/            # Data models (Request/Response)
├── analyzer/          # Content analysis and scoring
└── config/            # Configuration and AI platform presets

E2E Testing

An end-to-end testing CLI tool is available in examples/e2e/ for validating the complete optimization workflow.

cd examples/e2e

# Configure your GLM API key
cp .env.example .env
# Edit .env and add your GLM_API_KEY

# Run all tests
go run .

# Run specific scenario
go run . --scenario=basic
go run . --scenario=full_flow

# Verbose output
go run . --verbose

The E2E tests validate:

• Basic Functionality: LLM chat, content scoring, single strategy optimization
• Full Business Flow: Complete optimization pipeline with realistic enterprise data

Test reports are generated in examples/e2e/output/ with detailed Markdown summaries.

Documentation

See API.md for detailed API documentation.

Requirements

• Go 1.21+
• LLM API access (currently supports GLM)

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.