Aixgo v0.4.0: Go 1.26, Advanced Planning Strategies, Enhanced Security, and RAG Variants

# Install Go 1.26
# Visit https://go.dev/dl/ for installation instructions

# Verify version
go version  # Should show go1.26 or later

# Update your project
go get github.com/aixgo-dev/aixgo@v0.4.0
go mod tidy

security:
  jwt:
    enabled: true
    jwks_url: 'https://www.googleapis.com/oauth2/v3/certs' # Google
    # jwks_url: "https://YOUR_DOMAIN.auth0.com/.well-known/jwks.json"  # Auth0
    # jwks_url: "https://YOUR_DOMAIN.okta.com/oauth2/default/v1/keys"  # Okta
    issuer: 'https://accounts.google.com'
    audience: 'your-client-id.apps.googleusercontent.com'
    cache_ttl: '1h'

import "github.com/aixgo-dev/aixgo/pkg/security"

// JWT verification with Google
verifier, err := security.NewJWTVerifier(security.JWTConfig{
    JWKSUrl:  "https://www.googleapis.com/oauth2/v3/certs",
    Issuer:   "https://accounts.google.com",
    Audience: "your-app.apps.googleusercontent.com",
    CacheTTL: time.Hour,
})

// Verify incoming JWT
token := "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
claims, err := verifier.Verify(context.Background(), token)
if err != nil {
    return fmt.Errorf("invalid token: %w", err)
}

// Extract claims
userID := claims["sub"].(string)
email := claims["email"].(string)

user1=sk-1234567890abcdef
user2=sk-abcdef1234567890
admin=sk-fedcba0987654321

{
  "user1": "sk-1234567890abcdef",
  "user2": "sk-abcdef1234567890",
  "admin": "sk-fedcba0987654321"
}

security:
  api_keys:
    enabled: true
    file: '/etc/secrets/api-keys.txt'
    format: 'lines' # or "json"
    mode: 'plain' # Future: "encrypted"

// Load API keys from file
loader := security.NewFileAPIKeyLoader("/etc/secrets/api-keys.txt")
keys, err := loader.Load()
if err != nil {
    log.Fatal(err)
}

// Validate request
apiKey := r.Header.Get("X-API-Key")
if userID, ok := keys[apiKey]; ok {
    // Valid API key for userID
} else {
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
}

# Create secure API key file
echo "admin=sk-$(openssl rand -hex 32)" > /etc/secrets/api-keys.txt

# Set restrictive permissions
chmod 600 /etc/secrets/api-keys.txt

# Verify permissions
ls -l /etc/secrets/api-keys.txt
# Should show: -rw------- (600)

agents:
  - name: cot-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: chain_of_thought
      max_steps: 10
      prompt: 'Break down the task into logical steps with reasoning.'

Step 1: Load data from database (Reasoning: Need raw data first)
Step 2: Clean and normalize data (Reasoning: Remove outliers before analysis)
Step 3: Compute statistics (Reasoning: Need metrics for comparison)
Step 4: Generate report (Reasoning: Present findings)

agents:
  - name: tot-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: tree_of_thought
      branching_factor: 3
      max_depth: 4
      beam_width: 2 # Keep top 2 branches

agents:
  - name: react-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: react_planning
      max_iterations: 5
      tools:
        - name: search_documentation
          description: 'Search internal docs for information'
        - name: validate_approach
          description: 'Check if approach is feasible'

Iteration 1:
  Thought: Need to understand current system architecture
  Action: search_documentation("system architecture")
  Observation: System uses microservices with REST APIs

Iteration 2:
  Thought: Should validate if REST APIs support new feature
  Action: validate_approach("add GraphQL endpoint")
  Observation: GraphQL requires new gateway component

Iteration 3:
  Thought: Plan should include gateway setup first
  Action: finalize_plan()

agents:
  - name: mcts-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: monte_carlo_tree_search
      simulations: 100
      exploration_constant: 1.414 # sqrt(2), UCB1 standard
      max_depth: 5

agents:
  - name: backward-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: backward_chaining
      goal: 'Deploy application to production'
      validate_dependencies: true

Goal: Deploy application to production

Subgoal 1: Application passes all tests
  Required: Write tests (Subgoal 1.1)
  Required: Code is complete (Subgoal 1.2)

Subgoal 2: Infrastructure is ready
  Required: Provision servers (Subgoal 2.1)
  Required: Configure load balancer (Subgoal 2.2)

Dependency Graph: 1.1, 1.2 → 1 → 2.1, 2.2 → 2 → Goal

agents:
  - name: hierarchical-planner
    role: planner
    model: gpt-4-turbo
    planner_config:
      strategy: hierarchical
      levels: 3 # High-level → Mid-level → Low-level
      max_tasks_per_level: 5

Level 1 (High-Level Strategy):
  - Design system architecture
  - Implement core features
  - Test and deploy

Level 2 (Mid-Level Tasks):
  - Design system architecture:
    - Define API contracts
    - Choose technology stack
    - Create system diagram

Level 3 (Low-Level Actions):
  - Define API contracts:
    - Write OpenAPI spec
    - Review with stakeholders
    - Generate client SDKs

supervisor:
  name: standard-rag
  pattern: rag
  rag_config:
    retrieval_strategy: standard
    top_k: 5
    similarity_threshold: 0.7

Query: "How do I configure JWT authentication?"
  ↓
Retrieve: Top 5 docs with similarity > 0.7
  ↓
Generate: Answer using retrieved context

supervisor:
  name: conversational-rag
  pattern: rag
  rag_config:
    retrieval_strategy: conversational
    history_size: 100
    context_turns: 5
    top_k: 3

User: "How do I enable JWT?"
Bot: "Set jwt.enabled: true in config.yaml"

User: "What about the JWKS URL?"  ← References previous context
Bot: "Set jwt.jwks_url to your identity provider's endpoint"

User: "Can you show an example?"  ← Builds on conversation
Bot: "Here's a complete example using Google..."

supervisor:
  name: multi-query-rag
  pattern: rag
  rag_config:
    retrieval_strategy: multi_query
    num_queries: 3
    fusion_method: reciprocal_rank_fusion
    rrf_k: 60 # RRF parameter

Original: "How to optimize LLM performance?"

Variant 1: "What are best practices for LLM latency reduction?"
Variant 2: "How to reduce LLM API costs while maintaining quality?"
Variant 3: "What caching strategies improve LLM performance?"

RRF_score(doc) = Σ(1 / (k + rank_i))
where k=60, rank_i is doc position in query_i results

supervisor:
  name: hybrid-rag
  pattern: rag
  rag_config:
    retrieval_strategy: hybrid
    semantic_weight: 0.7
    keyword_weight: 0.3
    semantic_top_k: 10
    keyword_top_k: 10
    final_top_k: 5

Query: "JWT RS256 signature verification"

Semantic Results (cosine similarity):
  1. "Implementing JWT authentication" (0.89)
  2. "Token verification best practices" (0.85)
  3. "OAuth2 and OIDC guide" (0.78)

Keyword Results (BM25):
  1. "JWT signature algorithms" (contains "RS256")
  2. "Crypto/rsa signature verification" (exact match)
  3. "Implementing JWT authentication" (contains "JWT")

Merged (RRF):
  1. "Implementing JWT authentication" (high in both)
  2. "Crypto/rsa signature verification" (high keyword score)
  3. "JWT signature algorithms" (good keyword match)

{ "quality_score": 0.85, "feedback": "Good structure, needs examples" }

Quality Score: 8.5/10
Score: 0.85
Rating: 8.5 out of 10

supervisor:
  name: reflection-workflow
  pattern: reflection
  reflection_config:
    max_iterations: 3
    quality_threshold: 0.8
    score_extraction_method: 'json_first' # Try JSON, then regex, then sentiment

Iteration 1:
  Output: "The system handles authentication."
  Critique: "Too vague, lacks detail about methods"
  Score: 0.4

Iteration 2 (with refinement):
  Output: "The system supports JWT and OAuth2 authentication with RS256 signing."
  Critique: "Better, but missing configuration details"
  Score: 0.7

Iteration 3 (with refinement):
  Output: "The system supports JWT (RS256) and OAuth2 authentication. Configure via jwt.enabled and jwt.jwks_url in config.yaml. See docs/SECURITY.md for examples."
  Critique: "Complete and actionable"
  Score: 0.9 ✓

supervisor:
  name: multi-critic-reflection
  pattern: reflection
  reflection_config:
    num_critics: 3
    aggregation_method: average # or weighted_average, max, consensus
    critic_roles:
      - 'Technical accuracy reviewer'
      - 'Clarity and readability reviewer'
      - 'Completeness and examples reviewer'

Output: [Generated documentation]

Parallel Critique:
  Critic 1 (Technical): Score 0.9, "Accurate implementation details"
  Critic 2 (Clarity): Score 0.7, "Some sections unclear"
  Critic 3 (Examples): Score 0.6, "Needs more code examples"

Aggregated Score: (0.9 + 0.7 + 0.6) / 3 = 0.73
Combined Feedback: "Good technical accuracy. Improve clarity in sections 2-3 and add code examples."

Refinement: [Updated documentation with clearer explanations and examples]

// Manual schema definition
server.RegisterTool(mcp.Tool{
    Name: "get_weather",
    Description: "Get weather for a location",
    InputSchema: map[string]any{
        "type": "object",
        "properties": map[string]any{
            "location": map[string]any{"type": "string"},
            "units": map[string]any{"type": "string", "enum": []string{"celsius", "fahrenheit"}},
        },
        "required": []string{"location"},
    },
    Handler: func(ctx context.Context, args mcp.Args) (any, error) {
        location := args["location"].(string)  // Type assertion
        units := args["units"].(string)        // Type assertion
        return getWeather(location, units)
    },
})

// Define typed input struct
type WeatherInput struct {
    Location string `json:"location" jsonschema:"required,description=City name"`
    Units    string `json:"units,omitempty" jsonschema:"enum=celsius|fahrenheit,default=celsius"`
}

// Type-safe registration
server.RegisterTypedTool("get_weather", "Get weather for a location",
    func(ctx context.Context, input WeatherInput) (any, error) {
        return getWeather(input.Location, input.Units)
    },
)

type ComplexInput struct {
    Name     string   `json:"name" jsonschema:"required,minLength=1,maxLength=100"`
    Age      int      `json:"age" jsonschema:"minimum=0,maximum=120"`
    Email    string   `json:"email" jsonschema:"format=email"`
    Tags     []string `json:"tags,omitempty" jsonschema:"uniqueItems=true"`
    Priority string   `json:"priority" jsonschema:"enum=low|medium|high"`
}

// Automatic validation errors
Input: {"name": "", "age": 150}

Error: "validation failed:
  - name: must have minimum length of 1
  - age: must be at most 120"

# Run full test suite
make test

# Run specific feature tests
go test ./pkg/security -v -run TestJWT
go test ./internal/supervisor/patterns -v -run TestRAG
go test ./agents -v -run TestPlanner

# Check current version
go version

# Install Go 1.26
# Visit https://go.dev/dl/ for your platform

# Verify installation
go version
# Output: go version go1.26.0 darwin/arm64

# Update dependency
go get github.com/aixgo-dev/aixgo@v0.4.0

# Update all dependencies
go mod tidy

# Verify build
go build ./...

# Before
FROM golang:1.24-alpine

# After
FROM golang:1.26-alpine

# Run tests with race detector
go test -race ./...

# Check for deprecated APIs
go vet ./...

# Run linter
golangci-lint run

# GitHub Actions example
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/setup-go@v4
        with:
          go-version: '1.26' # Update from 1.24

go get github.com/aixgo-dev/aixgo@v0.4.0