Trading with Claude (and writing your own MCP server)

package help

import (
	"context"

	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
	"snaptrade.com/mcp-server/internal/snaptradeclient"
)

// This just defines a new tool using the MCP framework. It's important to have
// clear and helpful tool name and descriptions, as that's what Claude uses
// to determine when and whether to run your tool.
var Tool = mcp.NewTool("get_started_with_brokerage_connection",
	mcp.WithDescription("Provides information on how to connect your brokerage account and lists the supported brokerages."),
)

// Each tool has a handler that returns a function matching the `go-mcp`
// tool handler function signature. We use this to make it easy to pass
// an instance of `snaptradeclient.SnapTradeClient` which holds all the
// code interacting with SnapTrade via the SnapTrade Go SDK
func Handler(cl *snaptradeclient.SnapTradeClient) server.ToolHandlerFunc {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		// Note: This specific handler doesn't currently *use* the client,
		// but we adapt the signature for consistency and future use.
		return mcp.NewToolResultText("To get started with investing and portfolio management, please let us know which brokerage you have an account with. We can help you connect your account to any of the following brokerages: Trading212, Vanguard, Schwab, Alpaca, Alpaca Paper, Tradier, Robinhood, Fidelity, ETrade."), nil
	}
}

package connect

import (
	"context"
	"fmt"

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

	"snaptrade.com/mcp-server/internal/snaptradeclient"
)

var Tool = mcp.NewTool("connect_brokerage",
	mcp.WithDescription("Connect your brokerage account to see your portfolio and trades for that account."),
	mcp.WithString("brokerage",
		mcp.Required(),
		mcp.Description("The brokerage to connect to"),
		mcp.Enum("Trading212", "Vanguard", "Schwab", "Alpaca", "Alpaca Paper", "Tradier", "Robinhood", "Fidelity", "ETrade"),
	),
)

func Handler(cl *snaptradeclient.SnapTradeClient) server.ToolHandlerFunc {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		brokerage, ok := request.Params.Arguments["brokerage"].(string)
		if !ok {
			return mcp.NewToolResultError("Invalid brokerage"), nil
		}

        // The SnapTrade API takes these slugs to pre-select the brokerage to connect to, so we need to map the user's choice to the correct slug.
		nameToSlug := map[string]string{
			"Trading212":   "TRADING212",
			"Vanguard":     "VANGUARD",
			"Schwab":       "SCHWAB",
			"Alpaca":       "ALPACA",
			"Alpaca Paper": "ALPACA-PAPER",
			"Tradier":      "TRADIER",
			"Robinhood":    "ROBINHOOD",
			"Fidelity":     "FIDELITY",
			"ETrade":       "ETRADE",
		}
		slug, ok := nameToSlug[brokerage]
		if !ok {
			return mcp.NewToolResultError("Invalid brokerage"), nil
		}

        // This calls our custom SnapTrade client and grabs a URL to present to
        // the user. They will then need to click it to connect.
		redirectURI, err := cl.LoginUserAndGetRedirectURI(slug)
		if err != nil {
			return mcp.NewToolResultError("Failed to generate connection link for SnapTrade"), nil
		}

		return mcp.NewToolResultText(fmt.Sprintf("To connect to %s, you must present this link to the user. Please note that it expires, so even if you've shown it before, you need to show this new one:\n %s", brokerage, redirectURI)), nil
	}
}

package portfolio

import (
	"context"
	"fmt"

	"github.com/fbiville/markdown-table-formatter/pkg/markdown"
	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
	st "github.com/passiv/snaptrade-sdks/sdks/go"

	"snaptrade.com/mcp-server/internal/snaptradeclient"
)

var Tool = mcp.NewTool("portfolio",
	mcp.WithDescription("Check your portfolio and brokerage accounts for their positions and values.")
)

func Handler(cl *snaptradeclient.SnapTradeClient) server.ToolHandlerFunc {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		// Use the client method
		response, err := cl.ListUserAccounts()
		if err != nil {
			fmt.Println("Error retrieving accounts:", err)
			return mcp.NewToolResultError("Error retrieving accounts"), nil
		}
		if len(response) == 0 {
			fmt.Println("No brokerage accounts connected")
			return mcp.NewToolResultError("No brokerage accounts connected"), nil
		}

		reply := "Your connected brokerage accounts are:\n"

		// Group the accounts by institution
		accounts := make(map[string][]st.Account)
		for _, account := range response {
			institution := account.GetInstitutionName()
			if _, ok := accounts[institution]; !ok {
				accounts[institution] = []st.Account{}
			}
			accounts[institution] = append(accounts[institution], account)
		}

		// Find all accounts
		for institution, accountsList := range accounts {
			reply += fmt.Sprintf("%s:\n", institution)
			for _, account := range accountsList {
				marketValueDescription := ""
				if account.Balance.GetTotal().Amount != nil && account.Balance.GetTotal().Currency != nil {
					marketValue := *account.Balance.GetTotal().Amount
					marketValueCurrency := *account.Balance.GetTotal().Currency
					marketValueDescription = fmt.Sprintf("(value including cash: %.2f %s)", marketValue, marketValueCurrency)
				}
				reply += fmt.Sprintf("%s %s\n\nPlease show this markdown formatted table of all the positions under this account\n\n", *account.Name.Get(), marketValueDescription)

				// Now get all the positions for this account using the client method
				positions, err := cl.GetUserAccountPositions(account.Id)
				if err != nil {
					fmt.Println("Error retrieving positions for account", account.Name, ":", err)
					continue // Or add an error message to the reply
				}
				if len(positions) == 0 {
					reply += fmt.Sprintf("  - No positions found for account %s\n", *account.Name.Get())
					continue
				} else {
					tableData := make([][]string, len(positions))
					for i, position := range positions {
						tableData[i] = []string{
							position.Symbol.Symbol.Symbol,
							fmt.Sprintf("%.4f", *position.Units.Get()),
							fmt.Sprintf("%.2f %s", *position.Price.Get()**position.Units.Get(), *position.Symbol.Symbol.Currency.Code),
						}
					}

					basicTable, err := markdown.NewTableFormatterBuilder().
						Build("Instrument", "Units", "Value").
						Format(tableData)
					if err != nil {
						fmt.Println("Error creating table:", err)
						continue // Or add an error message to the reply
					}
					// Add the table to the reply
					reply += fmt.Sprintf("%s\n", basicTable)
				}
			}
		}

		fmt.Println(reply)
		return mcp.NewToolResultText(reply), nil
	}
}

package trades

import (
	"context"
	"fmt"

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

	"snaptrade.com/mcp-server/internal/snaptradeclient" // Use snaptradeclient instead of snaptrade
)

var Tool = mcp.NewTool("place_order",
	mcp.WithDescription("Place an order with your brokerage account"),
	mcp.WithString("brokerage",
		mcp.Required(),
		mcp.Description("The brokerage to place an order with"),
		mcp.Enum("Trading212", "Vanguard", "Schwab", "Alpaca", "Alpaca Paper", "Tradier", "Robinhood", "Fidelity", "ETrade"),
	),
	mcp.WithString("action",
		mcp.Required(),
		mcp.Description("The action to perform (BUY/SELL)"),
		mcp.Enum("BUY", "SELL"),
	),
	mcp.WithString("ticker",
		mcp.Required(),
		mcp.Description("The ticker symbol of the stock"),
	),
	mcp.WithNumber("quantity",
		mcp.Required(),
		mcp.Description("The quantity of shares to buy/sell"),
	),
)

func Handler(cl *snaptradeclient.SnapTradeClient) server.ToolHandlerFunc {
	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		brokerage, ok := request.Params.Arguments["brokerage"].(string)
		if !ok {
			return mcp.NewToolResultError("Invalid brokerage"), nil
		}
		action, ok := request.Params.Arguments["action"].(string)
		if !ok {
			return mcp.NewToolResultError("Invalid action"), nil
		}
		ticker, ok := request.Params.Arguments["ticker"].(string)
		if !ok {
			return mcp.NewToolResultError("Invalid ticker"), nil
		}
		quantity, ok := request.Params.Arguments["quantity"].(float64)
		if !ok {
			return mcp.NewToolResultError("Invalid quantity"), nil
		}
		quantityFloat := float32(quantity)

		// Use the client method
		response, err := cl.ListUserAccounts()
		if err != nil {
			fmt.Println("Error retrieving accounts:", err)
			return mcp.NewToolResultError("Error retrieving accounts"), nil // Return error to MCP
		}
		if len(response) == 0 {
			return mcp.NewToolResultError("No brokerage accounts connected"), nil
		}

		accountId := ""
		for _, account := range response {
			if account.GetInstitutionName() == brokerage {
				accountId = account.Id
				break // Found the account
			}
		}
		if accountId == "" {
			return mcp.NewToolResultError(fmt.Sprintf("No matching account found for brokerage: %s", brokerage)), nil
		}

		// Use the client method
		orderRecord, err := cl.PlaceForceOrder(accountId, action, ticker, quantityFloat)
		if err != nil {
			fmt.Println("Error placing order:", err)
			return mcp.NewToolResultError(fmt.Sprintf("Error placing order: %s", err.Error())), nil // Return error to MCP
		}

		return mcp.NewToolResultText(fmt.Sprintf("Order placed successfully: %s. You can monitor the status of your order by asking me to show your recent orders.", *orderRecord.BrokerageOrderId)), nil
	}
}