{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-zeromicro--go-zero","slug":"zeromicro--go-zero","name":"go-zero","type":"framework","url":"https://go-zero.dev","page_url":"https://unfragile.ai/zeromicro--go-zero","categories":["app-builders"],"tags":["ai-native","ai-native-development","cloud-native","code-generation","framework","gateway","go","golang","grpc-gateway","microservice","microservice-framework","microservices","microservices-architecture","rest-api","restful","restful-api","rpc","rpc-framework","spec-driven-development","web-framework"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-zeromicro--go-zero__cap_0","uri":"capability://code.generation.editing.spec.driven.rest.api.scaffolding.from.api.definition.files","name":"spec-driven rest api scaffolding from .api definition files","description":"Generates complete, production-ready REST API service scaffolding from declarative .api files using goctl's parser and code generation pipeline. The tool parses the .api definition format (which supports route definitions, request/response structs, middleware declarations, and service metadata), then generates typed handler stubs, request/response binding code, middleware chains, and server initialization logic. Developers fill in only business logic; all HTTP plumbing, validation, and routing is auto-generated and type-safe.","intents":["Generate a complete REST API service structure from a single API definition file without writing boilerplate","Ensure type safety between API contracts and handler implementations","Scaffold multi-endpoint services with consistent request/response handling patterns","Reduce time from API design to runnable service from hours to minutes"],"best_for":["Go microservice teams adopting spec-driven development","Developers building REST APIs with strict type contracts","Teams migrating from manual scaffolding to definition-first workflows"],"limitations":[".api format is go-zero-specific; no OpenAPI/Swagger input support (requires manual conversion or separate tooling)","Generated code assumes go-zero's rest.Server and middleware patterns; tight coupling to framework","No support for complex nested route hierarchies or dynamic routing patterns beyond static definitions"],"requires":["Go 1.19 or later","goctl CLI installed (version 1.10.0+)",".api file with valid syntax"],"input_types":[".api definition files (text-based DSL)"],"output_types":["Go source files (handlers, models, server setup)","Project directory structure"],"categories":["code-generation-editing","spec-driven-development"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_1","uri":"capability://code.generation.editing.grpc.service.scaffolding.and.gateway.generation.from.proto.files","name":"grpc service scaffolding and gateway generation from .proto files","description":"Generates complete gRPC service implementations, client stubs, and REST-to-gRPC gateway code from Protocol Buffer definitions using goctl's proto parser and code generation. The tool parses .proto files, generates gRPC server interfaces with go-zero's zrpc.Server integration, produces typed client code with built-in resilience (circuit breaker, timeout, retry), and optionally generates a gRPC-JSON gateway for REST clients. All generated code includes service discovery integration, distributed tracing hooks, and middleware support.","intents":["Generate gRPC service stubs and clients from .proto definitions with zero manual boilerplate","Create a REST gateway that translates HTTP requests to gRPC calls automatically","Ensure type-safe RPC communication across microservices","Add resilience patterns (circuit breaker, timeout) to gRPC clients without manual implementation"],"best_for":["Microservice teams using gRPC for inter-service communication","Teams needing both gRPC and REST API surfaces for the same service","Organizations adopting service mesh patterns with strong typing"],"limitations":["Gateway generation requires additional configuration; not all gRPC features map cleanly to REST (streaming, bidirectional calls)","Generated client code is tightly coupled to go-zero's zrpc.Client; difficult to use with other gRPC client libraries","Proto file changes require full regeneration; no incremental code generation support"],"requires":["Go 1.19 or later","goctl CLI with proto support","protoc compiler installed",".proto files with valid syntax"],"input_types":[".proto definition files (Protocol Buffer format)"],"output_types":["Go gRPC service interface implementations","Typed gRPC client code with resilience wrappers","REST gateway code (optional)","Service discovery and middleware integration code"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_10","uri":"capability://automation.workflow.middleware.and.interceptor.chain.composition.for.cross.cutting.concerns","name":"middleware and interceptor chain composition for cross-cutting concerns","description":"Provides a flexible middleware/interceptor system for HTTP handlers and gRPC services that allows composing cross-cutting concerns (authentication, logging, rate limiting, CORS) without modifying handler code. Middleware is registered in the server configuration and applied to all requests in a chain; each middleware can inspect/modify requests, call the next middleware, and inspect/modify responses. Interceptors work similarly for gRPC. Custom middleware can be added by implementing the middleware interface and registering it in the server setup.","intents":["Apply authentication, logging, rate limiting, and other cross-cutting concerns to all requests","Compose multiple middleware in a clean, reusable way","Avoid duplicating cross-cutting logic across handlers","Add new concerns (e.g., rate limiting) without modifying existing handlers"],"best_for":["Teams building REST APIs or gRPC services with multiple cross-cutting concerns","Organizations wanting to enforce consistent policies (auth, rate limiting) across services","Developers building reusable middleware libraries"],"limitations":["Middleware order matters; incorrect ordering can cause unexpected behavior","Middleware is applied globally; no per-route middleware configuration","Error handling in middleware can be complex; errors must be properly propagated","Middleware performance overhead accumulates with each layer"],"requires":["Go 1.19 or later","go-zero rest.Server or zrpc.Server","Custom middleware implementation (optional)"],"input_types":["HTTP requests/responses or gRPC calls"],"output_types":["Modified requests/responses with cross-cutting concerns applied"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_11","uri":"capability://data.processing.analysis.configuration.management.with.yaml.toml.json.file.loading.and.validation","name":"configuration management with yaml/toml/json file loading and validation","description":"Provides centralized configuration management through ServiceConf, which loads configuration from YAML/TOML/JSON files and validates it against a config struct. The framework supports environment variable substitution, nested configuration sections, and type-safe config access. ServiceConf.MustLoad() reads the config file, validates all required fields, and returns a populated config struct. Configuration includes database connections, Redis settings, service discovery, logging, tracing, and custom application config. Invalid config causes startup failure with clear error messages.","intents":["Load service configuration from files without manual parsing","Validate configuration at startup to catch errors early","Support environment variable substitution for secrets and deployment-specific settings","Organize configuration in a type-safe, structured way"],"best_for":["Go microservices requiring centralized configuration","Teams deploying services to multiple environments (dev, staging, prod)","Organizations wanting to enforce configuration validation"],"limitations":["Configuration is loaded at startup; no runtime configuration changes","No built-in config versioning or rollback","Environment variable substitution is basic; no complex templating","Config validation is struct-tag based; complex validation logic requires custom code"],"requires":["Go 1.19 or later","go-zero ServiceConf","Configuration file (YAML/TOML/JSON)"],"input_types":["YAML/TOML/JSON configuration files"],"output_types":["Typed config struct with validated values"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_12","uri":"capability://code.generation.editing.docker.and.kubernetes.deployment.manifest.generation","name":"docker and kubernetes deployment manifest generation","description":"Generates Dockerfile and Kubernetes manifests (Deployment, Service, ConfigMap) from service definitions using goctl's deployment generators. The tool creates a production-ready Dockerfile with multi-stage builds, generates Kubernetes YAML for service deployment with resource limits, health checks, and environment variable configuration. Generated manifests follow Kubernetes best practices and can be deployed directly to a cluster. Developers customize manifests as needed for their environment.","intents":["Generate production-ready Docker images without writing Dockerfile","Create Kubernetes manifests for service deployment","Ensure consistent deployment configuration across services","Reduce time from code to deployed service"],"best_for":["Teams deploying Go services to Kubernetes","Organizations wanting standardized deployment configurations","Developers new to Docker/Kubernetes wanting templates"],"limitations":["Generated manifests are templates; customization is required for production use","No support for advanced Kubernetes features (StatefulSets, DaemonSets, custom resources)","Docker image optimization is basic; no support for custom build stages","No integration with CI/CD pipelines; manifests must be deployed manually or via external tools"],"requires":["Go 1.19 or later","goctl CLI","Docker installed (to build images)","Kubernetes cluster (to deploy manifests)"],"input_types":[".api or .proto service definitions"],"output_types":["Dockerfile","Kubernetes YAML manifests (Deployment, Service, ConfigMap)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_13","uri":"capability://automation.workflow.mapreduce.and.concurrent.task.execution.with.automatic.goroutine.management","name":"mapreduce and concurrent task execution with automatic goroutine management","description":"Provides a MapReduce abstraction for parallel task execution with automatic goroutine management, error handling, and result aggregation. The framework provides Mapper and Reducer interfaces; developers implement map and reduce functions, and the framework handles goroutine creation, synchronization, and error collection. Useful for batch processing, data transformation, and parallel computation. The framework limits concurrent goroutines to prevent resource exhaustion and collects errors from all goroutines.","intents":["Execute tasks in parallel without manually managing goroutines","Process large datasets by splitting work across multiple goroutines","Aggregate results from parallel tasks","Handle errors from parallel tasks without losing other results"],"best_for":["Services performing batch processing or data transformation","Teams wanting to parallelize work without manual goroutine management","Applications processing large datasets"],"limitations":["MapReduce model is limited to simple map/reduce patterns; complex workflows require custom code","No support for distributed MapReduce (single-machine only)","Error handling collects all errors; no early termination on first error","Goroutine limit is global; no per-task concurrency control"],"requires":["Go 1.19 or later","go-zero with MapReduce support"],"input_types":["Data to process, map and reduce functions"],"output_types":["Aggregated results, error list"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_2","uri":"capability://code.generation.editing.database.model.generation.from.sql.schemas.with.automatic.crud.and.caching","name":"database model generation from sql schemas with automatic crud and caching","description":"Generates type-safe Go data access code from SQL schema definitions (.sql files) using goctl's schema parser. The tool analyzes table definitions, generates model structs with field tags, produces CRUD methods (Create, Read, Update, Delete), and automatically wraps database queries with go-zero's caching layer (Redis integration). Generated code includes prepared statement handling, transaction support, and hooks for distributed tracing. Developers call generated methods; all SQL execution and cache invalidation is handled automatically.","intents":["Generate type-safe data access layer from SQL schema without writing SQL queries manually","Add transparent caching (Redis) to database queries without modifying business logic","Ensure consistent CRUD patterns across all database tables","Reduce SQL injection risks through parameterized query generation"],"best_for":["Go teams using SQL databases with Redis caching","Microservices requiring fast, type-safe data access with automatic cache management","Teams wanting to avoid manual ORM configuration"],"limitations":["Generated code assumes Redis for caching; no pluggable cache backends","Complex queries (joins, aggregations, subqueries) require manual SQL; generator only handles simple CRUD","Schema changes require full regeneration of data access layer; no migration support built-in","Cache invalidation strategy is simple (TTL-based); no sophisticated cache coherence patterns"],"requires":["Go 1.19 or later","goctl CLI with sql support",".sql file with CREATE TABLE statements","Redis instance (for caching layer)"],"input_types":[".sql files (SQL DDL statements)"],"output_types":["Go model structs with database tags","CRUD method implementations","Cache wrapper code","Transaction handling code"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_3","uri":"capability://code.generation.editing.multi.language.typed.client.sdk.generation","name":"multi-language typed client sdk generation","description":"Generates type-safe client SDKs in multiple programming languages (Go, TypeScript, Kotlin, Dart, etc.) from .api or .proto definitions using goctl's language-specific code generators. Each generated SDK includes request/response models matching the service contract, method stubs for all endpoints, and language-native error handling. The generated clients are standalone and can be published to language-specific package repositories (npm, Maven, pub.dev). No runtime dependency on go-zero is required in client code.","intents":["Generate client libraries for multiple languages from a single API definition","Ensure client-server contract consistency across language boundaries","Reduce manual client implementation and keep clients in sync with API changes","Publish language-specific SDKs to package registries (npm, Maven, etc.)"],"best_for":["Platform teams publishing APIs to multiple client ecosystems","Organizations with polyglot microservice architectures","Teams wanting to enforce API contracts across language boundaries"],"limitations":["Generated clients are basic; no built-in resilience patterns (retry, circuit breaker) in non-Go SDKs","Language-specific idioms may not map cleanly from .api/.proto definitions","Generated code quality varies by language; Go clients are most mature","No support for custom client middleware or interceptors in generated code"],"requires":["Go 1.19 or later","goctl CLI with multi-language support",".api or .proto definition files"],"input_types":[".api definition files or .proto files"],"output_types":["Language-specific source files (Go, TypeScript, Kotlin, Dart, etc.)","Model/struct definitions","Client class/module implementations"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_4","uri":"capability://data.processing.analysis.automatic.http.request.binding.and.validation","name":"automatic http request binding and validation","description":"Automatically binds HTTP request data (query parameters, path variables, request body, headers) to typed Go structs and validates them according to struct tags using go-zero's rest.Server request handling pipeline. The framework uses reflection and struct tag parsing to map incoming HTTP data to struct fields, applies validation rules (required, range, pattern, custom validators), and returns structured error responses if validation fails. All binding and validation happens before handler code executes; handlers receive fully validated, typed data.","intents":["Automatically parse and validate HTTP request data without manual parsing code","Ensure type safety for all incoming request data","Return consistent, structured error responses for validation failures","Reduce boilerplate in handler functions"],"best_for":["REST API developers wanting automatic request validation","Teams enforcing strict input validation across all endpoints","Microservices requiring consistent error response formats"],"limitations":["Validation rules are limited to struct tags; complex conditional validation requires custom validators","Binding is struct-based; no support for dynamic/untyped request handling","Error messages are generated from validation rules; limited customization of error text","No built-in support for file upload validation beyond basic checks"],"requires":["Go 1.19 or later","go-zero rest.Server","Request struct with validation tags"],"input_types":["HTTP requests (query params, path vars, JSON body, headers)"],"output_types":["Typed Go structs","Validation error responses (JSON)"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_5","uri":"capability://automation.workflow.built.in.resilience.patterns.with.automatic.circuit.breaker.and.timeout.enforcement","name":"built-in resilience patterns with automatic circuit breaker and timeout enforcement","description":"Provides automatic resilience protection for HTTP and gRPC clients through go-zero's client wrappers, which inject circuit breaker, timeout, and retry logic without requiring handler code changes. The framework monitors client call success/failure rates, opens circuits when failure thresholds are exceeded, enforces configurable timeouts on all requests, and retries failed calls with exponential backoff. All resilience behavior is configured through YAML/TOML config files; no code changes needed to enable protection.","intents":["Protect microservices from cascading failures caused by downstream service outages","Enforce request timeouts to prevent hanging requests","Automatically retry transient failures without handler code","Monitor and respond to service degradation in real-time"],"best_for":["Microservice teams building resilient distributed systems","Organizations operating services in unstable network conditions","Teams wanting to avoid manual resilience implementation"],"limitations":["Circuit breaker configuration is global per service; no per-endpoint customization","Retry logic is basic (exponential backoff); no jitter or adaptive retry strategies","No built-in bulkhead isolation; all requests share the same circuit breaker state","Timeout enforcement is at the client level; server-side timeout handling is separate"],"requires":["Go 1.19 or later","go-zero rest.Client or zrpc.Client","Configuration file with circuit breaker settings"],"input_types":["Configuration (YAML/TOML) with circuit breaker thresholds, timeouts, retry counts"],"output_types":["Protected client calls with automatic resilience behavior"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_6","uri":"capability://data.processing.analysis.structured.logging.with.automatic.request.tracing.and.context.propagation","name":"structured logging with automatic request tracing and context propagation","description":"Provides structured, JSON-formatted logging integrated into all go-zero components (HTTP handlers, gRPC calls, database queries) with automatic request ID generation and context propagation across service boundaries. The framework logs all requests/responses, database operations, and service calls with consistent field names and trace IDs. Context (request ID, user ID, etc.) is automatically propagated through the call chain and included in all log entries. Logs are written to stdout/stderr in JSON format for easy parsing by log aggregation systems.","intents":["Trace requests across multiple microservices using request IDs","Aggregate and search logs from multiple services using structured fields","Debug issues by following request context through the entire call chain","Monitor service health through log analysis"],"best_for":["Microservice teams using centralized log aggregation (ELK, Datadog, etc.)","Organizations requiring request tracing across service boundaries","Teams debugging distributed system issues"],"limitations":["Log format is fixed (JSON); no support for custom formats","Log level configuration is global; no per-component log level control","No built-in log sampling or filtering; all requests are logged","Context propagation requires explicit middleware setup; not automatic for all code paths"],"requires":["Go 1.19 or later","go-zero rest.Server or zrpc.Server","Log aggregation system (optional but recommended)"],"input_types":["HTTP requests, gRPC calls, database queries"],"output_types":["JSON-formatted log entries with trace IDs and context"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_7","uri":"capability://automation.workflow.distributed.tracing.integration.with.opentelemetry.hooks","name":"distributed tracing integration with opentelemetry hooks","description":"Provides built-in integration points for distributed tracing systems (Jaeger, Zipkin, DataDog) through OpenTelemetry instrumentation. The framework automatically creates spans for HTTP requests, gRPC calls, and database queries, and propagates trace context across service boundaries using standard trace headers. Developers configure a trace exporter (Jaeger, Zipkin, etc.) in ServiceConf; all tracing is automatic. Spans include timing information, error status, and custom attributes set by handlers.","intents":["Visualize request flow across multiple microservices in a trace viewer","Identify performance bottlenecks in distributed systems","Correlate errors across services using trace IDs","Monitor end-to-end latency of user requests"],"best_for":["Microservice teams using distributed tracing systems (Jaeger, Zipkin)","Organizations monitoring end-to-end request latency","Teams debugging performance issues in distributed systems"],"limitations":["Tracing is automatic but limited to go-zero components; custom code requires manual span creation","Trace sampling is configured globally; no per-request sampling decisions","Trace exporter must be configured in ServiceConf; no runtime configuration changes","Overhead of tracing is always incurred; no zero-cost abstraction for disabled tracing"],"requires":["Go 1.19 or later","go-zero rest.Server or zrpc.Server","Trace exporter (Jaeger, Zipkin, DataDog, etc.)","OpenTelemetry SDK"],"input_types":["HTTP requests, gRPC calls, database queries"],"output_types":["Trace spans with timing and context information"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_8","uri":"capability://memory.knowledge.redis.backed.caching.layer.with.automatic.cache.invalidation","name":"redis-backed caching layer with automatic cache invalidation","description":"Provides transparent Redis caching for database queries and RPC calls through go-zero's cache abstraction layer. Developers configure cache TTL and keys in code or config; the framework automatically stores query results in Redis, returns cached values on subsequent calls, and invalidates cache entries when data is modified. Cache misses trigger database queries; hits return Redis values. The caching layer handles Redis connection pooling, serialization, and error handling (fallback to database on cache failures).","intents":["Reduce database load by caching frequently accessed data","Improve response times for read-heavy workloads","Automatically manage cache invalidation on data updates","Handle cache failures gracefully without breaking the application"],"best_for":["Services with read-heavy workloads and moderate write frequency","Teams wanting transparent caching without application code changes","Microservices using Redis for distributed caching"],"limitations":["Cache invalidation is simple (TTL-based or manual); no sophisticated cache coherence","Cache keys must be manually defined; no automatic key generation for complex queries","No cache warming or preloading strategies","Cache is per-Redis-instance; no distributed cache invalidation across multiple instances"],"requires":["Go 1.19 or later","go-zero with cache support","Redis instance","Cache configuration (TTL, key patterns)"],"input_types":["Database queries, RPC calls, cache configuration"],"output_types":["Cached data from Redis or database"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zeromicro--go-zero__cap_9","uri":"capability://tool.use.integration.service.discovery.and.load.balancing.with.automatic.client.side.routing","name":"service discovery and load balancing with automatic client-side routing","description":"Provides client-side service discovery and load balancing for gRPC and HTTP calls through go-zero's client wrappers. The framework integrates with service registries (Consul, etcd, Kubernetes DNS) to discover available service instances, automatically routes requests to healthy instances using configurable load balancing strategies (round-robin, least-conn, random), and removes unhealthy instances from the pool. Service discovery is configured in ServiceConf; client code doesn't need to know about instance addresses.","intents":["Automatically discover and route to available service instances","Handle service instance failures without manual failover","Load balance requests across multiple instances","Simplify client code by hiding service discovery complexity"],"best_for":["Microservice teams using service registries (Consul, etcd, Kubernetes)","Organizations with dynamic service instances (auto-scaling)","Teams wanting automatic failover without manual configuration"],"limitations":["Service discovery is client-side; no server-side load balancing","Load balancing strategies are limited (round-robin, least-conn, random); no advanced algorithms","Service registry integration is limited to Consul, etcd, Kubernetes; no custom registry support","Health checking is basic (TCP/HTTP); no sophisticated health check strategies"],"requires":["Go 1.19 or later","go-zero rest.Client or zrpc.Client","Service registry (Consul, etcd, Kubernetes)","Service discovery configuration in ServiceConf"],"input_types":["Service registry configuration, load balancing strategy"],"output_types":["Routed requests to healthy service instances"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":55,"verified":false,"data_access_risk":"high","permissions":["Go 1.19 or later","goctl CLI installed (version 1.10.0+)",".api file with valid syntax","goctl CLI with proto support","protoc compiler installed",".proto files with valid syntax","go-zero rest.Server or zrpc.Server","Custom middleware implementation (optional)","go-zero ServiceConf","Configuration file (YAML/TOML/JSON)"],"failure_modes":[".api format is go-zero-specific; no OpenAPI/Swagger input support (requires manual conversion or separate tooling)","Generated code assumes go-zero's rest.Server and middleware patterns; tight coupling to framework","No support for complex nested route hierarchies or dynamic routing patterns beyond static definitions","Gateway generation requires additional configuration; not all gRPC features map cleanly to REST (streaming, bidirectional calls)","Generated client code is tightly coupled to go-zero's zrpc.Client; difficult to use with other gRPC client libraries","Proto file changes require full regeneration; no incremental code generation support","Middleware order matters; incorrect ordering can cause unexpected behavior","Middleware is applied globally; no per-route middleware configuration","Error handling in middleware can be complex; errors must be properly propagated","Middleware performance overhead accumulates with each layer","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7926161724756546,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:58:37.059Z","last_commit":"2026-04-27T23:23:17Z"},"community":{"stars":32978,"forks":4291,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=zeromicro--go-zero","compare_url":"https://unfragile.ai/compare?artifact=zeromicro--go-zero"}},"signature":"jUG2xMDlXc9FQDRZnBvfZDZiR3pK9SjH4M1YFZMroPCs1PP3YcgPJWRkhqz7cBzMl8yonp94M39rRI+MbmOrCg==","signedAt":"2026-06-20T07:46:18.746Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/zeromicro--go-zero","artifact":"https://unfragile.ai/zeromicro--go-zero","verify":"https://unfragile.ai/api/v1/verify?slug=zeromicro--go-zero","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}