geo-optimizer - GitLite

KO | EN

gitlite — search

#javascript #python #hacktoberfest #typescript #llm #docker #nodejs #macos #cli #kubernetes #awesome-list #pytorch #ios #openai

geo-optimizer

(★ 190)

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

파일 탐색기

최종 버전 다운로드 (.zip)

- geo-optimizer_logo.png
- - .env.example
  - .gitignore
  - go.mod
  - main.go
  - README.md
- - scorer.go
  - scorer_ai.go
  - scorer_test.go
- - ai_profiles.go
- - client.go
  - glm.go
  - glm_integration_test.go
  - glm_test.go
  - parser.go
  - provider.go
  - test_analysis.md
  - test_chat.md
  - test_optimization.md
  - test_schema.md
- - content.go
  - request.go
  - response.go
- - optimizer.go
  - optimizer_test.go
.gitignore
API.md
CLAUDE.md
CONTRIBUTING.md
go.mod
LICENSE
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/geo-team-red/geo-optimizer

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd geo-optimizer

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Go

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Go Go 언어 컴파일러 및 도구 모음입니다.

go run .

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

go run . --scenario=basic

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

go run . --scenario=full_flow

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

go run . --verbose

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

✅ 빌드가 에러 없이 끝나면 성공입니다. go run . 을 썼다면 터미널 출력을 확인하세요.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<div align="center">
  <img src="./assets/geo-optimizer_logo.png" alt="geo-optimizer" width="500">
  <h1>GEO Optimizer: Make Your Content Visible to AI Engines</h1>
  <p>
    <a href="https://pkg.go.dev/github.com/Lin-Jiong-HDU/geo-optimizer"><img src="https://pkg.go.dev/badge/github.com/Lin-Jiong-HDU/geo-optimizer.svg" alt="Go Reference"></a>
    <a href="https://goreportcard.com/report/github.com/Lin-Jiong-HDU/geo-optimizer"><img src="https://goreportcard.com/badge/github.com/Lin-Jiong-HDU/geo-optimizer" alt="Go Report Card"></a>
    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
  </p>
</div>

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

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

## Quick Start

```go
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:

```go
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

```go
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.

```bash
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](./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](LICENSE) file for details.

## Contributing

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