贝叶斯优化服务器

# Clone the repository
git clone https://github.com/copyleftdev/TUNDR.git
cd TUNDR

# Install dependencies
go mod download

# Build the server
go build -o bin/server ./cmd/server

# Start the server with default configuration
./bin/server

# Or with custom configuration
CONFIG_FILE=config/local.yaml ./bin/server

# Build the Docker image
docker build -t tundr/mcp-optimization-server .

# Run the container
docker run -p 8080:8080 tundr/mcp-optimization-server

{
  "error": {
    "code": 400,
    "message": "Invalid input parameters"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "Invalid params"
  }
}

package main

import (
	"context"
	"fmt"
	"math"
	
	"github.com/copyleftdev/TUNDR/internal/optimization"
	"github.com/copyleftdev/TUNDR/internal/optimization/bayesian"
)

func main() {
	// Define the objective function (to be minimized)
	objective := func(x []float64) (float64, error) {
		// Example: Rosenbrock function
		return math.Pow(1-x[0], 2) + 100*math.Pow(x[1]-x[0]*x[0], 2), nil
	}

	// Define parameter bounds
	bounds := [][2]float64{{-5, 5}, {-5, 5}}

	// Create optimizer configuration
	config := optimization.OptimizerConfig{
		Objective:      objective,
		Bounds:         bounds,
		MaxIterations:  50,
		NInitialPoints: 10,
	}

	// Create and run the optimizer
	optimizer, err := bayesian.NewBayesianOptimizer(config)
	if err != nil {
		panic(fmt.Sprintf("Failed to create optimizer: %v", err))
	}

	// Run the optimization
	result, err := optimizer.Optimize(context.Background(), config)
	if err != nil {
		panic(fmt.Sprintf("Optimization failed: %v", err))
	}

	// Print results
	fmt.Printf("Optimal parameters: %v\n", result.BestSolution.Parameters)
	fmt.Printf("Optimal value: %f\n", result.BestSolution.Value)
	fmt.Printf("Number of iterations: %d\n", result.Iterations)
	fmt.Printf("Converged: %v\n", result.Converged)
}

server:
  port: 8080
  env: development
  timeout: 30s

logging:
  level: info
  format: json
  output: stdout

optimization:
  max_concurrent: 4
  default_kernel: "matern52"
  default_acquisition: "ei"
  
storage:
  type: "memory"  # or "postgres"
  dsn: ""  # Only needed for postgres

metrics:
  enabled: true
  path: "/metrics"
  namespace: "tundr"
  
tracing:
  enabled: false
  service_name: "mcp-optimization-server"
  endpoint: "localhost:4317"

# Run all tests
go test ./...

# Run tests with coverage
go test -coverprofile=coverage.out ./... && go tool cover -html=coverage.out

# Run benchmarks
go test -bench=. -benchmem ./...

# Application
ENV=development
LOG_LEVEL=info
HTTP_PORT=8080

# Database
DB_TYPE=sqlite  # sqlite or postgres
DB_DSN=file:data/tundr.db?cache=shared&_fk=1

# Authentication
JWT_KEY=your-secure-key-change-in-production

# Optimization
MAX_CONCURRENT_JOBS=10
JOB_TIMEOUT=30m

# Monitoring
METRICS_ENABLED=true
METRICS_PORT=9090

server:
  env: development
  port: 8080
  shutdown_timeout: 30s

database:
  type: sqlite
  dsn: file:data/tundr.db?cache=shared&_fk=1
  max_open_conns: 25
  max_idle_conns: 5
  conn_max_lifetime: 5m

optimization:
  max_concurrent_jobs: 10
  job_timeout: 30m
  default_algorithm: bayesian
  
  bayesian:
    default_kernel: matern52
    default_noise: 1e-6
    max_observations: 1000
    
  cma_es:
    population_size: auto  # auto or number
    max_generations: 1000

monitoring:
  metrics:
    enabled: true
    port: 9090
    path: /metrics
  
  tracing:
    enabled: false
    endpoint: localhost:4317
    sample_rate: 0.1

logging:
  level: info
  format: json
  enable_caller: true
  enable_stacktrace: true

make dev

make build
./bin/tundr serve --config config/production.yaml

# Build the Docker image
docker build -t tundr-optimization .

# Run the container
docker run -p 8080:8080 -v $(pwd)/data:/app/data tundr-optimization

package main

import (
	"context"
	"fmt"
	"log"
	"math"


	"github.com/tundr/mcp-optimization-server/internal/optimization"
	"github.com/tundr/mcp-optimization-server/internal/optimization/bayesian"
	"github.com/tundr/mcp-optimization-server/internal/optimization/kernels"
)

func main() {
	// Define the objective function (to be minimized)
	objective := func(x []float64) (float64, error) {
		// Example: Rosenbrock function
		return math.Pow(1-x[0], 2) + 100*math.Pow(x[1]-x[0]*x[0], 2), nil
	}

	// Define parameter bounds
	bounds := []optimization.Parameter{
		{Name: "x1", Min: -5.0, Max: 10.0},
		{Name: "x2", Min: -5.0, Max: 10.0},
	}

	// Create optimizer configuration
	config := optimization.OptimizerConfig{
		Objective:      objective,
		Parameters:     bounds,
		NInitialPoints: 10,
		MaxIterations:  50,
		Verbose:        true,
	}

	// Create and configure the optimizer
	optimizer, err := bayesian.NewBayesianOptimizer(config)
	if err != nil {
		log.Fatalf("Failed to create optimizer: %v", err)
	}

	// Run the optimization
	result, err := optimizer.Optimize(context.Background())
	if err != nil {
		log.Fatalf("Optimization failed: %v", err)
	}

	// Print results
	fmt.Printf("Best solution: %+v\n", result.BestSolution)
	fmt.Printf("Best value: %f\n", result.BestSolution.Value)
	fmt.Printf("Number of iterations: %d\n", len(result.History))
}

curl -X POST http://localhost:8080/api/v1/optimize \
  -H "Content-Type: application/json" \
  -d '{
    "algorithm": "bayesian",
    "objective": "minimize",
    "parameters": [
      {"name": "x1", "type": "float", "bounds": [-5.0, 10.0]},
      {"name": "x2", "type": "float", "bounds": [-5.0, 10.0]}
    ],
    "max_iterations": 100,
    "n_initial_points": 20,
    "metadata": {
      "name": "rosenbrock-optimization",
      "tags": ["test", "demo"]
    }
  }'

curl http://localhost:8080/api/v1/status/<job_id>

type Kernel interface {
    Eval(x, y []float64) float64
    Hyperparameters() []float64
    SetHyperparameters(params []float64) error
    Bounds() [][2]float64
}

type MyCustomKernel struct {
    lengthScale float64
    variance    float64
}

func (k *MyCustomKernel) Eval(x, y []float64) float64 {
    // Implement your custom kernel function
    sumSq := 0.0
    for i := range x {
        diff := x[i] - y[i]
        sumSq += diff * diff
    }
    return k.variance * math.Exp(-0.5*sumSq/(k.lengthScale*k.lengthScale))
}

// Implement other required methods...

config := optimization.OptimizerConfig{
    Objective:      objective,
    Parameters:     bounds,
    NInitialPoints: 10,
    MaxIterations:  50,
    NJobs:         4,  // Use 4 parallel workers
}

optimizer := bayesian.NewBayesianOptimizer(config)

// Add a callback that's called after each iteration
optimizer.AddCallback(func(result *optimization.OptimizationResult) {
    fmt.Printf("Iteration %d: Best value = %f\n", 
        len(result.History), 
        result.BestSolution.Value)
})

POST /api/v1/optimize
Content-Type: application/json

{
  "algorithm": "bayesian",
  "objective": "minimize",
  "parameters": [
    {"name": "x", "type": "float", "bounds": [0, 10], "prior": "uniform"},
    {"name": "y", "type": "float", "bounds": [-5, 5], "prior": "normal", "mu": 0, "sigma": 1}
  ],
  "constraints": [
    {"type": "ineq", "expr": "x + y <= 10"}
  ],
  "options": {
    "max_iterations": 100,
    "n_initial_points": 20,
    "acquisition": "ei",
    "xi": 0.01,
    "kappa": 0.1
  },
  "metadata": {
    "name": "example-optimization",
    "tags": ["test"],
    "user_id": "user123"
  }
}

GET /api/v1/status/:id

{
  "id": "job-123",
  "status": "running",
  "progress": 0.45,
  "best_solution": {
    "parameters": {"x": 1.2, "y": 3.4},
    "value": 0.123
  },
  "start_time": "2025-06-30T10:00:00Z",
  "elapsed_time": "1h23m45s",
  "iterations": 45,
  "metadata": {
    "name": "example-optimization",
    "tags": ["test"]
  }
}

POST /rpc
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "optimization.start",
  "params": [
    {
      "algorithm": "bayesian",
      "objective": "minimize",
      "parameters": [
        {"name": "x", "type": "float", "bounds": [0, 10]},
        {"name": "y", "type": "float", "bounds": [-5, 5]}
      ],
      "options": {
        "max_iterations": 100,
        "n_initial_points": 20,
        "acquisition": "ei",
        "xi": 0.01
      }
    }
  ]
}

config := optimization.OptimizerConfig{
    // ... other options ...
    NJobs: runtime.NumCPU(),  // Use all available CPUs
}

kernel := kernels.NewMatern52Kernel(1.0, 1.0)
kernel.EnableCache(true)  // Enable kernel cache

# Run tests
make test

# Run linters
make lint

# Run benchmarks
make benchmark

# Format code
make fmt

# Generate documentation
make docs

make build

make test

make lint

docker build -t tundr/mcp-optimization-server .
docker run -p 8080:8080 --env-file .env tundr/mcp-optimization-server