About 🚀 Go-Tapd-SDK
Go-Tapd-SDK is a Go client library for accessing the Tapd API. It is intended for Go developers building applications or webhook handlers that use Tapd; the README marks the current version as non-stable and not recommended for production.
Key features
- 01Tapd API access from Go
- 02Basic Authentication API service
- 03Personal Access Token API service
- 04Webhook server example
Use cases
- 01Call Tapd APIs from a Go application
- 02Authenticate API requests with Basic Authentication
- 03Use a Personal Access Token for API access
- 04Build a Tapd webhook handler
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.
Tools
Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.
Details
From the project README🚀 Go-Tapd-SDK
The Go-Tapd-SDK is a Go client library for accessing the Tapd API.
Warning
This is currently still a non-stable version, is not recommended for production use.
If you encounter any issues, you are welcome to submit an issue.
🧰 Command Line Tool
Note
🧰 Prefer terminal or CI usage? Try the sibling project
go-tapd/cli, a command line tool built on this SDK.⚙️ Use the CLI for quick local operations, shell scripts, and automation. See the repository for installation and usage examples.
📥 Installation
go get github.com/go-tapd/tapd
✨ Features
see features.md
🔧 Usage
API Service
- Example of using the Basic Authentication API service:
package main
import (
"context"
"log"
"github.com/go-tapd/tapd"
)
func main() {
client, err := tapd.NewClient("client_id", "client_secret")
if err != nil {
log.Fatal(err)
}
// example: get labels
labels, _, err := client.LabelService.GetLabels(context.Background(), &tapd.GetLabelsRequest{
WorkspaceID: new(123456),
})
if err != nil {
log.Fatal(err)
}
log.Printf("labels: %+v", labels)
}
- Example of using the Personal Access Token (PAT) API service:
package main
import (
"context"
"log"
"github.com/go-tapd/tapd"
)
func main() {
client, err := tapd.NewPATClient("your_access_token")
if err != nil {
log.Fatal(err)
}
// example: get stories
stories, _, err := client.StoryService.GetStories(context.Background(), &tapd.GetStoriesRequest{
WorkspaceID: new(123456),
})
if err != nil {
log.Fatal(err)
}
log.Printf("stories: %+v", stories)
}
Webhook Server Example
package main
import (
"context"
"log"
"net/http"
"github.com/go-tapd/tapd/webhook"
)
type StoreUpdateListener struct{}
func (l *StoreUpdateListener) OnStoryUpdate(ctx context.Context, event *webhook.StoryUpdateEvent) error {
log.Printf("StoreUpdateListener: %+v", event)
return nil
}
func main() {
dispatcher := webhook.NewDispatcher(
webhook.WithRegisters(&StoreUpdateListener{}),
)
dispatcher.Registers(&StoreUpdateListener{})
srv := http.NewServeMux()
srv.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
log.Println("Received webhook request")
if err := dispatcher.DispatchRequest(r); err != nil {
log.Println(err)
}
w.Write([]byte("ok"))
})
http.ListenAndServe(":8080", srv)
}
📜 License
The MIT License (MIT). Please see License File for more information.
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.