Explore

Talk to Agent Nil before the Chain opens. Daily challenges. No wallets, no tokens, only the game.

Hosted by author·No license·Few stars·No key

The neutral standard for connecting systems to agents — Network Intent Layer (NIL) + the nilscript DSL. USB for software.

MCP·Link only·★ 9

Generates Test::Unit tests in Ruby. Classic xUnit-style testing with assert methods and test case classes. Use when user mentions "Test::Unit", "assert_equal Ruby", "Ruby test-unit". Triggers on: "Tes

in the skill textwith 'test_' def test_create_user user = UserService.create('Alice', 'alice@test.com') assert_not_nil(user) assert_equal('Alice', user.name) end def test_find_user_by_email user

Official·Skill·MIT·★ 376 in collection·No key

Generates RSpec tests in Ruby with describe/context/it blocks, matchers, let/before hooks, and mocking. Use when user mentions "RSpec", "describe do", "expect().to", "Ruby test". Triggers on: "RSpec",

in the skill texttruthy expect(value).to be_falsey expect(value).to be_nil # Collections expect(array).to include(3) expect(array).to contain_exactly(1, 2, 3) expect

Official·Skill·MIT·★ 376 in collection·No key

Transform any Cobra CLI into an MCP server

in the readmepackage main import ( "os" "github.com/njayp/ophis" ) func main() { rootCmd := createMyRootCommand() rootCmd.AddCommand(ophis.Command(nil)) if err := rootCmd.Execute(); err != nil { os.Exit(1) } } ``` ### Enable in Claude Desktop, VSCode

Go·Apache-2.0·★ 93·No key

A Go adapter that bridges LangChain Go tools with Model Context Protocol (MCP) servers.

in the readmeusing stdio mcpClient, err := client.NewStdioMCPClient( "./an-mcp-server", // Path to an MCP server executable nil, // Additional environment variables if needed ) if err != nil { log.Fatalf("Failed to create MCP

Go·MIT·★ 48·No key

Build Model Context Protocol (MCP) servers in Go

in the readmemcp.Response[mcp.InitializeResponse], error) { return mcp.NewResponse(&mcp.InitializeResponse{ ProtocolVersion: req.Params.ProtocolVersion, Capabilities: mcp.ServerCapabilities{ Resources: &mcp.Resources{}, }, }), nil } func (s *FSServer) ListResources(ctx context.Context, req *mcp.Request[mcp.Lis

Go·MIT·★ 36·No key

Terminal UI engine for Go that tests can click and AI agents can drive (MCP). Zero-allocation rendering, immediate mode + Elm architecture, 3D, images, charts, accessibility, WebAssembly.

in the readme/thebanri/limoni" func main() { limoni.Run(func(f *limoni.Frame, ev *limoni.Event) bool { if ev != nil && ev.Type == limoni.EventKey && ev.Key.Type == limoni.KeyEsc { return false // quit } f.RenderComponent(limoni.Border( limoni.Center(limoni.Label("Hello from

Go·Apache-2.0·★ 154·No key

HAR Skills — AI-native library for HAR file analysis. Access via: Skills (CLAUDE.md), Go SDK, CLI, MCP. 23 commands, 70+ methods, progressive disclosure docs.

in the skill texttools, workers, CI jobs, and MCP servers. - **Automation-safe behavior**: typed errors, nil-safe public APIs, streaming/lazy parsing, redaction, validation, and deterministic export helpers. - **MCP-ready

Skill·MIT·★ 38·No key

AhaSend MCP server tools. Lets AI agents send email, check delivery, and manage domains, webhooks and campaigns through the AhaSend API.

in the readmeAccountID: accountID, DashboardBaseURL: " ConfirmationKey: key, // at least 32 random bytes }, ) if err != nil { return err } return server.Run(ctx, &mcp.StdioTransport{}) ``` ## Options | Field | What it does | |---|---| | `Client` | The

Hosted by author·MIT·Few stars·No key

A composable multi-agent AI framework for Go that makes it easy to build production-ready AI applications.

in the readme/calque-ai/go-calque/pkg/middleware/ai" "github.com/calque-ai/go-calque/pkg/middleware/ai/ollama" ) func main() { client, err := ollama.New("llama3.2:3b") if err != nil { log.Fatal(err) } flow := calque.NewFlow().Use(ai.Agent(client)) var result string err = flow.Run(context.Background

Go·MPL-2.0·★ 9·No key

Define a Go struct. Get a CLI that an agent can discover, call, sandbox, and debug. Flags, env vars, config files, validation, JSON Schema, MCP, structured errors, and WASM. Built on Cobra.

in the readmeRunE: func(c *cobra.Command, args []string) error { fmt.Println(opts) // already populated return nil }, } structcli.Bind(cli, opts) structcli.ExecuteOrExit(cli) } ``` `Bind` creates flags and env vars from your

Go·MIT·★ 18·No key

Observability engine for AI coding agents. Custom columnar log store, MCP-native, self-hosted on a $4/mo VM. No dashboards — your AI assistant sees production.

in the readmeerrors, 12 affected users. Root cause: NilPointerError at payments_controller.rb:87 — customer.address is nil when charging. This started after the latest deploy (commit a1b2c3d by dev@company.com). The commit

Go·MIT·★ 15·No key

Extract every UUID, ULID, NanoID, ObjectId and Snowflake, and decode the time inside

in the readmeUUID v7s, and when was each minted? - **Reviewing a config** — the placeholder nil UUID that escaped into production - **Before trusting a hex string** — whether the document

Node.js·MIT·★ 1·Few stars·No key

A composable commerce engine for Go: catalog, carts, checkout, orders, payments and inventory as a library, with an embedded admin panel. One production dependency.

in the readmeSENDGRID_API_KEY"), From: "orders@example.com", }), invoices.New(invoices.Config{SellerName: "Example Ltd"}), ) if err != nil { log.Fatal(err) } log.Fatal(app.ListenAndServe()) ``` The engine imports as `github.com/itswadesh/gocommerce/core`; the package

Go·MIT·★ 7·No key

Go library, CLI and MCP server for CNN's Fear & Greed Index: current score, rating and a year of daily history

in the readmefmt" cnnfag "github.com/wildsurfer/cnn-fear-and-greed-parse/v2" ) func main() { result, err := cnnfag.Get(context.Background()) if err != nil { panic(err) } fmt.Printf("Now: %.0f (%s)\n", result.Score, result.Rating) fmt.Printf("One year ago

Docker·MIT·★ 2·Few stars·No key

Generate a complete Go MCP server project with proper structure, dependencies, and implementation using the official github.com/modelcontextprotocol/go-sdk.

in the skill texttools.RegisterTools(server) // Run server transport := &mcp.StdioTransport{} if err := server.Run(ctx, transport); err != nil { log.Fatalf("Server error: %v", err) } } ``` ## tools/tool1.go Template ```go package tools import ( "context" "fmt

Official·Skill·MIT·★ 40k in collection·No key

Build agentic applications with GitHub Copilot SDK. Use when embedding AI agents in apps, creating custom tools, implementing streaming responses, managing sessions, connecting to MCP servers, or crea

in the skill textmain import ( "fmt" "log" "os" copilot "github.com/github/copilot-sdk/go" ) func main() { client := copilot.NewClient(nil) if err := client.Start(); err != nil { log.Fatal(err) } defer client.Stop() session, err := client.CreateSession(&copilot.SessionConfig

Official·Skill·MIT·★ 40k in collection·No key

Convert Markdown files to HTML similar to `marked.js`, `pandoc`, `gomarkdown/markdown`, or similar tools; or writing custom script to convert markdown to html and/or working on web template systems li

in the skill textbyte("# Hello World\n\nThis is **bold** text.") html := markdown.ToHTML(md, nil, nil) fmt.Println(string(html)) } ``` #### Method 2: CLI Tool ```bash # Install mdtohtml go install github.com

Official·Skill·MIT·★ 40k in collection·No key

Guide GitHub Copilot through V language development: installing the toolchain, project layout with v.mod, building, testing, formatting, and writing idiomatic V including Option/Result error handling.

in the skill textType`). Handle them with `or { ... }` blocks; never invent null checks. Pointer-level `nil` exists only in low-level `unsafe`/C-interop contexts (e.g. `unsafe { nil }`) and should

Official·Skill·MIT·★ 40k in collection·No key

Terraform provider acceptance test patterns using terraform-plugin-testing with the Plugin Framework. Covers test structure, TestCase/TestStep fields, ConfigStateChecks with custom statecheck.StateChe

in the skill textconfig triggered the bug Config: testAccExampleConfig_regressionGH1234(rName), ConfigStateChecks: []statecheck.StateCheck{ stateCheckExampleExists(resourceName, nil), statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("computed_field"), knownvalue.NotNull()), }, }, }, }) } ``` --- ## Helper

Official·Skill·MPL-2.0·★ 894 in collection·No key

Use when the user asks about using Gemini in an enterprise environment or explicitly mentions Vertex AI, Google Cloud, or Agent Platform. Guides the usage of the Gemini API on Agent Platform with the

in the skill textctx, &genai.ClientConfig{ Backend: genai.BackendVertexAI, Project: "your-project-id", Location: "global", }) if err != nil { log.Fatal(err) } resp, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", genai.Text("Explain quantum computing

Official·Skill·Apache-2.0·★ 21k in collection·No key