MCP Server dan Implementasinya dengan Go

// data/reports.json
{
  "reports": [
    {
      "id": "rpt-001",
      "title": "Laporan Keuangan Q1 2025",
      "department": "finance",
      "period": "Q1 2025",
      "created_at": "2025-01-15T08:00:00Z",
      "created_by": "[email protected]",
      "status": "published",
      "summary": "Total pendapatan Q1 mencapai Rp 4.2 miliar, naik 12% dari Q4 2024.",
      "figures": {
        "revenue": 4200000000,
        "expenses": 2800000000,
        "net_profit": 1400000000,
        "growth_pct": 12.4
      }
    },
    {
      "id": "rpt-002",
      "title": "Laporan Keuangan Q2 2025",
      "department": "finance",
      "period": "Q2 2025",
      "created_at": "2025-04-10T09:30:00Z",
      "created_by": "[email protected]",
      "status": "published",
      "summary": "Pertumbuhan melambat di Q2 akibat kenaikan biaya operasional.",
      "figures": {
        "revenue": 4050000000,
        "expenses": 3100000000,
        "net_profit": 950000000,
        "growth_pct": -3.6
      }
    },
    {
      "id": "rpt-003",
      "title": "Laporan Operasional Semester 1",
      "department": "operations",
      "period": "H1 2025",
      "created_at": "2025-07-01T10:00:00Z",
      "created_by": "[email protected]",
      "status": "draft",
      "summary": "Efisiensi produksi meningkat 8% berkat implementasi sistem baru.",
      "figures": {
        "efficiency_pct": 8.2,
        "downtime_hours": 24,
        "output_units": 125000,
        "defect_rate_pct": 0.8
      }
    },
    {
      "id": "rpt-004",
      "title": "Laporan SDM Kuartal 2",
      "department": "hr",
      "period": "Q2 2025",
      "created_at": "2025-04-20T14:00:00Z",
      "created_by": "[email protected]",
      "status": "published",
      "summary": "Tingkat retensi karyawan 94%, rekrutmen 23 posisi baru.",
      "figures": {
        "headcount": 312,
        "new_hires": 23,
        "resignations": 18,
        "retention_pct": 94.2
      }
    }
  ]
}

// internal/store/reports.go
package store

import (
	"encoding/json"
	"fmt"
	"os"
	"sync"
	"time"
)

// Report merepresentasikan satu laporan dalam sistem
type Report struct {
	ID         string                 `json:"id"`
	Title      string                 `json:"title"`
	Department string                 `json:"department"`
	Period     string                 `json:"period"`
	CreatedAt  time.Time              `json:"created_at"`
	CreatedBy  string                 `json:"created_by"`
	Status     string                 `json:"status"`
	Summary    string                 `json:"summary"`
	Figures    map[string]interface{} `json:"figures"`
}

type database struct {
	Reports []Report `json:"reports"`
}

// ReportStore mengelola operasi baca-tulis ke backend service
type ReportStore struct {
	path string
	mu   sync.RWMutex
}

func NewReportStore(path string) *ReportStore {
	return &ReportStore{path: path}
}

func (s *ReportStore) load() (*database, error) {
	data, err := os.ReadFile(s.path)
	if err != nil {
		return nil, fmt.Errorf("gagal membaca file: %w", err)
	}
	var db database
	if err := json.Unmarshal(data, &db); err != nil {
		return nil, fmt.Errorf("gagal parse JSON: %w", err)
	}
	return &db, nil
}

func (s *ReportStore) save(db *database) error {
	data, err := json.MarshalIndent(db, "", "  ")
	if err != nil {
		return fmt.Errorf("gagal encode JSON: %w", err)
	}
	return os.WriteFile(s.path, data, 0644)
}

// GetAll mengembalikan semua laporan
func (s *ReportStore) GetAll() ([]Report, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	db, err := s.load()
	if err != nil {
		return nil, err
	}
	return db.Reports, nil
}

// GetByID mengembalikan laporan berdasarkan ID
func (s *ReportStore) GetByID(id string) (*Report, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	db, err := s.load()
	if err != nil {
		return nil, err
	}
	for _, r := range db.Reports {
		if r.ID == id {
			return &r, nil
		}
	}
	return nil, fmt.Errorf("laporan dengan ID '%s' tidak ditemukan", id)
}

// GetByDepartment mengembalikan laporan berdasarkan departemen
func (s *ReportStore) GetByDepartment(dept string) ([]Report, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	db, err := s.load()
	if err != nil {
		return nil, err
	}
	var result []Report
	for _, r := range db.Reports {
		if r.Department == dept {
			result = append(result, r)
		}
	}
	return result, nil
}

// Delete menghapus laporan berdasarkan ID
func (s *ReportStore) Delete(id string) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	db, err := s.load()
	if err != nil {
		return err
	}
	newReports := make([]Report, 0, len(db.Reports))
	found := false
	for _, r := range db.Reports {
		if r.ID == id {
			found = true
			continue
		}
		newReports = append(newReports, r)
	}
	if !found {
		return fmt.Errorf("laporan dengan ID '%s' tidak ditemukan", id)
	}
	db.Reports = newReports
	return s.save(db)
}

// internal/auth/jwt.go
package auth

import (
	"context"
	"fmt"
	"strings"
	"time"

	"github.com/MicahParks/keyfunc/v2"
	"github.com/golang-jwt/jwt/v5"
)

// Claims merepresentasikan payload JWT dari Authentik
type Claims struct {
	Sub            string   `json:"sub"`
	Email          string   `json:"email"`
	Name           string   `json:"name"`
	MCPPermissions []string `json:"mcp_permissions"`
	Department     string   `json:"department"`
	jwt.RegisteredClaims
}

// Validator memvalidasi JWT menggunakan JWKS dari Authentik
type Validator struct {
	jwks *keyfunc.JWKS
}

// NewValidator membuat Validator baru yang terhubung ke JWKS endpoint Authentik
func NewValidator(jwksURL string) (*Validator, error) {
	jwks, err := keyfunc.Get(jwksURL, keyfunc.Options{
		RefreshInterval: time.Hour,
		RefreshErrorHandler: func(err error) {
			// Log error refresh JWKS — jangan sampai server crash
			fmt.Printf("JWKS refresh error: %v\n", err)
		},
	})
	if err != nil {
		return nil, fmt.Errorf("gagal inisialisasi JWKS dari %s: %w", jwksURL, err)
	}
	return &Validator{jwks: jwks}, nil
}

// Validate memvalidasi token string dan mengembalikan claims jika valid
func (v *Validator) Validate(tokenStr string) (*Claims, error) {
	if tokenStr == "" {
		return nil, fmt.Errorf("token tidak boleh kosong")
	}

	claims := &Claims{}
	token, err := jwt.ParseWithClaims(tokenStr, claims, v.jwks.Keyfunc)
	if err != nil {
		return nil, fmt.Errorf("token tidak valid: %w", err)
	}
	if !token.Valid {
		return nil, fmt.Errorf("token sudah kedaluwarsa atau tidak valid")
	}

	return claims, nil
}

// ExtractFromContext mengambil Bearer token dari context MCP
// MCP client mengirim token via header Authorization: Bearer <token>
func ExtractFromContext(ctx context.Context) (string, error) {
	// mcp-go menyimpan authorization header di context dengan key ini
	authHeader, ok := ctx.Value("authorization").(string)
	if !ok || authHeader == "" {
		return "", fmt.Errorf("header Authorization tidak ditemukan di request")
	}

	const prefix = "Bearer "
	if !strings.HasPrefix(authHeader, prefix) {
		return "", fmt.Errorf("format Authorization harus 'Bearer <token>'")
	}

	token := strings.TrimPrefix(authHeader, prefix)
	if token == "" {
		return "", fmt.Errorf("token kosong setelah prefix Bearer")
	}

	return token, nil
}

// internal/rbac/policy.go
package rbac

import "fmt"

// toolPermissions mendefinisikan permission yang dibutuhkan setiap tool.
// Ini adalah satu-satunya tempat yang perlu diubah ketika kamu menambah tool baru
// atau mengubah aturan akses.
var toolPermissions = map[string]string{
	"list_reports":   "report:read",
	"get_report":     "report:read",
	"delete_report":  "report:delete",
}

// Check memverifikasi apakah daftar permission user mencakup permission
// yang dibutuhkan untuk tool yang diminta.
func Check(toolName string, userPermissions []string) error {
	required, exists := toolPermissions[toolName]
	if !exists {
		// Tool tidak terdaftar di policy — tolak sebagai langkah pengamanan
		return fmt.Errorf("tool '%s' tidak terdaftar dalam policy", toolName)
	}

	for _, p := range userPermissions {
		if p == required {
			return nil // ✓ Akses diizinkan
		}
	}

	return fmt.Errorf(
		"akses ditolak: tool '%s' membutuhkan permission '%s'",
		toolName, required,
	)
}

// RequiredPermission mengembalikan permission yang dibutuhkan sebuah tool.
// Berguna untuk pesan error yang informatif.
func RequiredPermission(toolName string) string {
	if p, ok := toolPermissions[toolName]; ok {
		return p
	}
	return "unknown"
}

// BENAR: selalu daftarkan permission untuk setiap tool baru
"create_report": "report:write",

// ANTI-PATTERN: membiarkan tool tanpa entry di policy
// Hasilnya: "tool tidak terdaftar dalam policy" → 403 otomatis
// Ini sebenarnya perilaku yang aman, tapi lebih baik eksplisit

// internal/tools/get_report.go
package tools

import (
	"context"
	"encoding/json"
	"fmt"

	"github.com/kamu/mcp-reports/internal/auth"
	"github.com/kamu/mcp-reports/internal/rbac"
	"github.com/kamu/mcp-reports/internal/store"
	"github.com/mark3labs/mcp-go/mcp"
)

// ReportTools membungkus semua tool yang berhubungan dengan laporan
type ReportTools struct {
	store     *store.ReportStore
	validator *auth.Validator
}

func NewReportTools(s *store.ReportStore, v *auth.Validator) *ReportTools {
	return &ReportTools{store: s, validator: v}
}

// checkAccess adalah helper internal yang melakukan auth + RBAC check.
// Semua tool memanggil ini sebagai langkah pertama.
func (t *ReportTools) checkAccess(ctx context.Context, toolName string) (*auth.Claims, error) {
	tokenStr, err := auth.ExtractFromContext(ctx)
	if err != nil {
		return nil, fmt.Errorf("unauthorized: %w", err)
	}

	claims, err := t.validator.Validate(tokenStr)
	if err != nil {
		return nil, fmt.Errorf("unauthorized: %w", err)
	}

	if err := rbac.Check(toolName, claims.MCPPermissions); err != nil {
		return nil, err // Pesan error dari RBAC sudah deskriptif
	}

	return claims, nil
}

// HandleListReports mengembalikan semua laporan yang tersedia.
// Membutuhkan permission: report:read
func (t *ReportTools) HandleListReports(
	ctx context.Context,
	req mcp.CallToolRequest,
) (*mcp.CallToolResult, error) {
	claims, err := t.checkAccess(ctx, "list_reports")
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	// Ambil filter opsional dari arguments
	deptFilter, _ := req.Params.Arguments["department"].(string)

	var reports []store.Report
	if deptFilter != "" {
		reports, err = t.store.GetByDepartment(deptFilter)
	} else {
		reports, err = t.store.GetAll()
	}
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("gagal mengambil data: %v", err)), nil
	}

	// Buat summary untuk setiap laporan (tidak expose figures detail)
	type reportSummary struct {
		ID         string `json:"id"`
		Title      string `json:"title"`
		Department string `json:"department"`
		Period     string `json:"period"`
		Status     string `json:"status"`
		CreatedBy  string `json:"created_by"`
	}

	summaries := make([]reportSummary, len(reports))
	for i, r := range reports {
		summaries[i] = reportSummary{
			ID:         r.ID,
			Title:      r.Title,
			Department: r.Department,
			Period:     r.Period,
			Status:     r.Status,
			CreatedBy:  r.CreatedBy,
		}
	}

	data, _ := json.MarshalIndent(map[string]interface{}{
		"total":       len(summaries),
		"reports":     summaries,
		"accessed_by": claims.Email,
	}, "", "  ")

	return mcp.NewToolResultText(string(data)), nil
}

// HandleGetReport mengembalikan detail lengkap satu laporan berdasarkan ID.
// Membutuhkan permission: report:read
func (t *ReportTools) HandleGetReport(
	ctx context.Context,
	req mcp.CallToolRequest,
) (*mcp.CallToolResult, error) {
	claims, err := t.checkAccess(ctx, "get_report")
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	reportID, ok := req.Params.Arguments["report_id"].(string)
	if !ok || reportID == "" {
		return mcp.NewToolResultError("parameter 'report_id' wajib diisi"), nil
	}

	report, err := t.store.GetByID(reportID)
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	data, _ := json.MarshalIndent(map[string]interface{}{
		"report":      report,
		"accessed_by": claims.Email,
		"accessed_at": "now",
	}, "", "  ")

	return mcp.NewToolResultText(string(data)), nil
}

// internal/tools/delete_report.go
package tools

import (
	"context"
	"fmt"

	"github.com/mark3labs/mcp-go/mcp"
)

// HandleDeleteReport menghapus laporan secara permanen dari file JSON.
// Membutuhkan permission: report:delete (hanya role admin)
func (t *ReportTools) HandleDeleteReport(
	ctx context.Context,
	req mcp.CallToolRequest,
) (*mcp.CallToolResult, error) {
	// RBAC check — hanya permission report:delete yang bisa sampai sini
	claims, err := t.checkAccess(ctx, "delete_report")
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	reportID, ok := req.Params.Arguments["report_id"].(string)
	if !ok || reportID == "" {
		return mcp.NewToolResultError("parameter 'report_id' wajib diisi"), nil
	}

	// Verifikasi laporan ada dulu sebelum dihapus
	report, err := t.store.GetByID(reportID)
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	if err := t.store.Delete(reportID); err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("gagal menghapus: %v", err)), nil
	}

	result := fmt.Sprintf(
		"Laporan '%s' (%s) berhasil dihapus oleh %s.",
		report.Title, report.ID, claims.Email,
	)

	return mcp.NewToolResultText(result), nil
}

// config/config.go
package config

import (
	"fmt"
	"os"
)

// Config menyimpan semua konfigurasi runtime MCP server
type Config struct {
	// AuthentikJWKSURL adalah URL JWKS endpoint dari OAuth2 provider di Authentik
	// Contoh: https://auth.company.com/application/o/mcp-reports/jwks/
	AuthentikJWKSURL string

	// DataPath adalah path ke file JSON yang menyimpan data laporan
	DataPath string

	// ServerPort adalah port HTTP tempat MCP server mendengarkan koneksi
	ServerPort string

	// ServerBaseURL adalah URL publik MCP server, digunakan oleh SSE transport
	ServerBaseURL string
}

// Load membaca konfigurasi dari environment variable dan memvalidasinya
func Load() (*Config, error) {
	cfg := &Config{
		AuthentikJWKSURL: getEnv("AUTHENTIK_JWKS_URL", ""),
		DataPath:         getEnv("DATA_PATH", "./data/reports.json"),
		ServerPort:       getEnv("SERVER_PORT", "3000"),
		ServerBaseURL:    getEnv("SERVER_BASE_URL", "http://localhost:3000"),
	}

	if cfg.AuthentikJWKSURL == "" {
		return nil, fmt.Errorf("AUTHENTIK_JWKS_URL wajib diisi")
	}

	return cfg, nil
}

func getEnv(key, fallback string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return fallback
}

// main.go
package main

import (
	"fmt"
	"log"

	"github.com/kamu/mcp-reports/config"
	"github.com/kamu/mcp-reports/internal/auth"
	"github.com/kamu/mcp-reports/internal/store"
	"github.com/kamu/mcp-reports/internal/tools"
	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)

func main() {
	// 1. Load konfigurasi dari environment
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("Konfigurasi tidak valid: %v", err)
	}

	// 2. Inisialisasi JWT validator yang terhubung ke Authentik JWKS
	validator, err := auth.NewValidator(cfg.AuthentikJWKSURL)
	if err != nil {
		log.Fatalf("Gagal inisialisasi JWT validator: %v", err)
	}

	// 3. Inisialisasi store yang membaca data dari file JSON
	reportStore := store.NewReportStore(cfg.DataPath)

	// 4. Buat instance tool handler
	reportTools := tools.NewReportTools(reportStore, validator)

	// 5. Buat MCP server dengan metadata
	s := server.NewMCPServer(
		"Report MCP Server",
		"1.0.0",
		server.WithToolCapabilities(true),
	)

	// 6. Daftarkan tool list_reports dengan schema inputnya
	s.AddTool(
		mcp.NewTool("list_reports",
			mcp.WithDescription(
				"Menampilkan daftar semua laporan yang tersedia. "+
					"Gunakan filter 'department' untuk mempersempit hasil. "+
					"Membutuhkan permission report:read.",
			),
			mcp.WithString("department",
				mcp.Description("Filter berdasarkan departemen (finance, operations, hr). Kosongkan untuk semua departemen."),
			),
		),
		reportTools.HandleListReports,
	)

	// 7. Daftarkan tool get_report
	s.AddTool(
		mcp.NewTool("get_report",
			mcp.WithDescription(
				"Mengembalikan detail lengkap satu laporan berdasarkan ID, "+
					"termasuk angka-angka finansial atau operasional. "+
					"Gunakan list_reports dulu untuk mendapatkan ID yang valid. "+
					"Membutuhkan permission report:read.",
			),
			mcp.WithString("report_id",
				mcp.Required(),
				mcp.Description("ID laporan dalam format 'rpt-XXX', contoh: rpt-001"),
			),
		),
		reportTools.HandleGetReport,
	)

	// 8. Daftarkan tool delete_report (hanya admin)
	s.AddTool(
		mcp.NewTool("delete_report",
			mcp.WithDescription(
				"Menghapus laporan secara permanen dari sistem. "+
					"TINDAKAN INI TIDAK BISA DIBATALKAN. "+
					"Hanya tersedia untuk user dengan permission report:delete (role admin). "+
					"Gunakan get_report dulu untuk memverifikasi laporan yang akan dihapus.",
			),
			mcp.WithString("report_id",
				mcp.Required(),
				mcp.Description("ID laporan yang akan dihapus dalam format 'rpt-XXX'"),
			),
		),
		reportTools.HandleDeleteReport,
	)

	// 9. Jalankan server menggunakan SSE transport
	addr := fmt.Sprintf(":%s", cfg.ServerPort)
	httpServer := server.NewSSEServer(s,
		server.WithBaseURL(cfg.ServerBaseURL),
	)

	log.Printf("MCP Report Server berjalan di %s", cfg.ServerBaseURL)
	log.Printf("SSE endpoint: %s/sse", cfg.ServerBaseURL)
	log.Printf("Data source: %s", cfg.DataPath)

	if err := httpServer.Start(addr); err != nil {
		log.Fatalf("Server gagal: %v", err)
	}
}

# Development — menggunakan Authentik lokal
export AUTHENTIK_JWKS_URL="https://authentik.local/application/o/mcp-reports/jwks/"
export DATA_PATH="./data/reports.json"
export SERVER_PORT="3000"
export SERVER_BASE_URL="http://localhost:3000"

go run ./main.go

# Test list_reports (perlu JWT yang valid dari Authentik)
curl -X POST http://localhost:3000/message \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <JWT_DARI_AUTHENTIK>" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "list_reports",
      "arguments": {}
    }
  }'

# Property Mapping di Authentik (Python expression)
# Nama mapping: "MCP Report Permissions"
# Scope name: "mcp"

user_groups = [g.name for g in request.user.ak_groups.all()]

permissions = []

# Admin mendapat semua permission
if "mcp-admin" in user_groups:
    permissions = ["report:read", "report:delete"]

# Finance dan Manager hanya bisa baca
elif any(g in user_groups for g in ["finance", "manager", "analyst"]):
    permissions = ["report:read"]

# User biasa tidak mendapat permission MCP apapun
# (token tetap valid tapi semua tool call akan ditolak)

return permissions

# Property Mapping: "MCP Department"
# Scope name: "mcp"

# Ambil departemen dari attribute user di Authentik
return request.user.attributes.get("department", "")

{
  "sub": "user-abc123",
  "email": "[email protected]",
  "mcp_permissions": ["report:read"],
  "department": "finance",
  "exp": 1234567890
}

{
  "sub": "user-xyz789",
  "email": "[email protected]",
  "mcp_permissions": ["report:read", "report:delete"],
  "department": "it",
  "exp": 1234567890
}