Go (Golang) LLM PII Masking: High-Throughput Local Sidecar Integration

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	openai "github.com/sashabaranov/go-openai"
)

type ScrubRequest struct {
	Text    string `json:"text"`
	Profile string `json:"profile"`
}

type ScrubResponse struct {
	SanitizedText string                 `json:"sanitizedText"`
	TokenMap      map[string]string      `json:"tokenMap"`
	Telemetry     map[string]interface{} `json:"telemetry"`
}

type UnscrubRequest struct {
	Text     string            `json:"text"`
	TokenMap map[string]string `json:"tokenMap"`
}

type UnscrubResponse struct {
	RestoredText string `json:"restoredText"`
}

func sanitizePrompt(sidecarURL, prompt, profile string) (*ScrubResponse, error) {
	reqBody, _ := json.Marshal(ScrubRequest{Text: prompt, Profile: profile})
	client := &http.Client{Timeout: 2 * time.Second}

	resp, err := client.Post(sidecarURL+"/scrub", "application/json", bytes.NewBuffer(reqBody))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var scrubRes ScrubResponse
	if err := json.NewDecoder(resp.Body).Decode(&scrubRes); err != nil {
		return nil, err
	}
	return &scrubRes, nil
}

func restoreResponse(sidecarURL, text string, tokenMap map[string]string) (string, error) {
	reqBody, _ := json.Marshal(UnscrubRequest{Text: text, TokenMap: tokenMap})
	client := &http.Client{Timeout: 2 * time.Second}

	resp, err := client.Post(sidecarURL+"/unscrub", "application/json", bytes.NewBuffer(reqBody))
	if err != nil {
		return text, err
	}
	defer resp.Body.Close()

	var unscrubRes UnscrubResponse
	if err := json.NewDecoder(resp.Body).Decode(&unscrubRes); err != nil {
		return text, err
	}
	return unscrubRes.RestoredText, nil
}

func main() {
	sidecarURL := "http://127.0.0.1:3100"
	apiKey := os.Getenv("OPENAI_API_KEY")
	aiClient := openai.NewClient(apiKey)

	userPrompt := "Schedule clinical intake for patient Johnathan Doe (SSN: 042-88-9124, Email: jdoe@enterprise.com)"

	// 1. Sanitize in local sidecar (<1.2ms)
	scrubbed, err := sanitizePrompt(sidecarURL, userPrompt, "General")
	if err != nil {
		log.Fatalf("Sanitization failed: %v", err)
	}

	// 2. Call OpenAI with sanitized tokens (0 PII egress)
	resp, err := aiClient.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: openai.GPT4o,
			Messages: []openai.ChatCompletionMessage{
				{Role: openai.ChatMessageRoleUser, Content: scrubbed.SanitizedText},
			},
		},
	)
	if err != nil {
		log.Fatalf("OpenAI call failed: %v", err)
	}

	// 3. Restore authentic customer details in local memory
	restored, _ := restoreResponse(sidecarURL, resp.Choices[0].Message.Content, scrubbed.TokenMap)
	fmt.Printf("Final Restored Output in Go Memory:\n%s\n", restored)
}