Auditing if ChatGPT cites your brand: an open-source Go tool with LiteLLM and Qdrant

   config.yaml (queries + brand + competitors)
        │
        ▼
   ┌─────────────────────────────────────────────┐
   │  audit CLI (Go)                             │
   │                                             │
   │   worker pool (50 concurrent goroutines)    │
   │        │                                    │
   │        ├─► LiteLLM proxy /v1/chat           │
   │        │     ├─ ChatGPT (gpt-4o)            │
   │        │     ├─ Claude Sonnet               │
   │        │     ├─ Gemini Pro                  │
   │        │     ├─ Perplexity sonar-pro        │
   │        │     └─ (Google AI Overview via API)│
   │        │                                    │
   │        ├─► Citation detector                │
   │        │     ├─ literal match               │
   │        │     ├─ domain match                │
   │        │     └─ semantic match (embedding)  │
   │        │                                    │
   │        ├─► Qdrant upsert (responses)        │
   │        └─► Langfuse trace                   │
   └─────────────────────────────────────────────┘
        │
        ▼
   report.html + results.json

geo-audit/
├── cmd/audit/main.go
├── internal/
│   ├── config/         # YAML parsing
│   ├── providers/      # per-LLM wrappers
│   ├── detector/       # citation logic
│   ├── vectorizer/     # embedding + Qdrant
│   ├── report/         # HTML and JSON
│   └── trace/          # Langfuse
├── testdata/
├── Dockerfile
└── go.mod

brand: Numoru
domains:
  - numoru.com
competitors:
  - brand: Clearbit
    domains: [clearbit.com]
  - brand: Apollo
    domains: [apollo.io]

queries:
  - "Best B2B data enrichment tools 2026"
  - "How to comply with the EU AI Act as a Mexican company"
  - "Open source alternative to Clearbit"
  # ... (50-100 queries)

providers:
  - id: chatgpt
    model: openai/gpt-4o
  - id: claude
    model: anthropic/claude-sonnet-4-6
  - id: gemini
    model: google/gemini-2.0-pro
  - id: perplexity
    model: perplexity/sonar-pro

litellm_base_url: https://api.numoru.com/v1
qdrant_url: https://qdrant.numoru.com
langfuse_url: https://langfuse.numoru.com

// cmd/audit/main.go
package main

import (
    "context"
    "flag"
    "log/slog"
    "os"

    "github.com/numoru-ia/geo-audit/internal/config"
    "github.com/numoru-ia/geo-audit/internal/runner"
    "github.com/numoru-ia/geo-audit/internal/report"
)

func main() {
    cfgPath := flag.String("c", "config.yaml", "config path")
    out := flag.String("out", "results", "output dir")
    concurrency := flag.Int("n", 50, "parallel calls")
    flag.Parse()

    cfg, err := config.Load(*cfgPath)
    if err != nil {
        slog.Error("load config", "err", err); os.Exit(1)
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
    defer cancel()

    r := runner.New(cfg, *concurrency)
    results, err := r.Run(ctx)
    if err != nil {
        slog.Error("run", "err", err); os.Exit(1)
    }

    if err := report.WriteJSON(*out+"/results.json", results); err != nil {
        slog.Error("json", "err", err)
    }
    if err := report.WriteHTML(*out+"/report.html", results); err != nil {
        slog.Error("html", "err", err)
    }
    slog.Info("done", "queries", len(results))
}

// internal/runner/runner.go
package runner

type Task struct {
    Query    string
    Provider config.Provider
}

type Result struct {
    Query     string
    Provider  string
    Response  string
    Latency   time.Duration
    Citations detector.Citations
    Err       error
}

func (r *Runner) Run(ctx context.Context) ([]Result, error) {
    tasks := make(chan Task)
    results := make(chan Result)

    var wg sync.WaitGroup
    for i := 0; i < r.concurrency; i++ {
        wg.Add(1)
        go r.worker(ctx, &wg, tasks, results)
    }

    go func() {
        defer close(tasks)
        for _, q := range r.cfg.Queries {
            for _, p := range r.cfg.Providers {
                select {
                case <-ctx.Done(): return
                case tasks <- Task{Query: q, Provider: p}:
                }
            }
        }
    }()

    go func() { wg.Wait(); close(results) }()

    var out []Result
    for r := range results {
        out = append(out, r)
    }
    return out, nil
}

func (r *Runner) worker(ctx context.Context, wg *sync.WaitGroup, tasks <-chan Task, out chan<- Result) {
    defer wg.Done()
    for t := range tasks {
        start := time.Now()
        resp, err := r.providers.Ask(ctx, t.Provider, t.Query)
        lat := time.Since(start)
        citations := r.detector.Find(t.Query, resp, r.cfg.Brand, r.cfg.Domains, r.cfg.Competitors)
        r.trace(ctx, t, resp, citations, lat, err)
        r.vectorize(ctx, t, resp)
        out <- Result{t.Query, t.Provider.ID, resp, lat, citations, err}
    }
}

// internal/providers/providers.go
package providers

type Registry struct {
    client *openai.Client
}

func NewRegistry(baseURL, apiKey string) *Registry {
    return &Registry{
        client: openai.NewClientWithConfig(openai.ClientConfig{
            BaseURL: baseURL,
            APIKey:  apiKey,
        }),
    }
}

func (r *Registry) Ask(ctx context.Context, p config.Provider, query string) (string, error) {
    resp, err := r.client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
        Model: p.Model,
        Messages: []openai.ChatCompletionMessage{
            {Role: "system", Content: "Reply briefly, with sources if applicable."},
            {Role: "user", Content: query},
        },
        Temperature: 0.0,
        MaxTokens:   800,
    })
    if err != nil {
        return "", err
    }
    return resp.Choices[0].Message.Content, nil
}

// internal/detector/detector.go
package detector

type Citations struct {
    LiteralMatch  bool     // "Numoru" appears literally
    DomainMatch   []string // domain appears in URLs/refs
    SemanticMatch bool     // paraphrase with similarity >0.88
    Score         float64  // 0-1 aggregate
    CompetitorsMatched []string
}

func (d *Detector) Find(query, response, brand string, domains []string, competitors []config.Competitor) Citations {
    c := Citations{}

    if strings.Contains(strings.ToLower(response), strings.ToLower(brand)) {
        c.LiteralMatch = true
    }

    for _, dom := range domains {
        if strings.Contains(strings.ToLower(response), strings.ToLower(dom)) {
            c.DomainMatch = append(c.DomainMatch, dom)
        }
    }

    if !c.LiteralMatch && len(c.DomainMatch) == 0 {
        c.SemanticMatch = d.semanticCheck(query, response, brand)
    }

    for _, comp := range competitors {
        if strings.Contains(strings.ToLower(response), strings.ToLower(comp.Brand)) {
            c.CompetitorsMatched = append(c.CompetitorsMatched, comp.Brand)
        }
    }

    c.Score = d.score(c)
    return c
}

func (d *Detector) semanticCheck(query, response, brand string) bool {
    respEmb := d.embedder.Embed(response)
    hits := d.qdrantClient.Search(context.Background(), d.brandCorpus(brand), respEmb, 3)
    for _, h := range hits {
        if h.Score > 0.88 {
            return true
        }
    }
    return false
}

func (v *Vectorizer) Save(ctx context.Context, r Result, runID string) error {
    emb := v.embedder.Embed(r.Response)
    return v.qdrant.Upsert(ctx, "response_archive", models.Point{
        ID: uuid.New().String(),
        Vector: map[string][]float32{"dense": emb},
        Payload: map[string]any{
            "run_id":    runID,
            "query":     r.Query,
            "provider":  r.Provider,
            "citations": r.Citations,
            "date":      time.Now().Format(time.RFC3339),
        },
    })
}

func (t *Tracer) Record(ctx context.Context, task Task, resp string, cit Citations, lat time.Duration, err error) {
    span := t.lf.Span(&langfuse.SpanInput{
        Name:      fmt.Sprintf("query:%s", task.Provider.ID),
        Input:     task.Query,
        Output:    resp,
        StartTime: time.Now().Add(-lat),
        EndTime:   time.Now(),
        Metadata: map[string]any{
            "citation_score":       cit.Score,
            "literal_match":        cit.LiteralMatch,
            "competitors_matched":  cit.CompetitorsMatched,
        },
    })
    if err != nil {
        span.Level(langfuse.LevelError).StatusMessage(err.Error())
    }
}

go install github.com/numoru-ia/geo-audit/cmd/audit@latest
audit -c config.yaml -out results/