Get started: set up a project

This guide takes you from an empty directory to a deployed MCP server that Claude Code can call. You build one tool, list-open-issues, which lists a GitHub repository’s open issues.

You need:

• A Glxymesh account and a terminal.
• The toolchain for the language you pick: Go, Node.js LTS for TypeScript, or Python 3.14. You need it only to run tools on your machine; the platform builds what you push.

Tip

Would you rather not write the code? Open Mesh Builder in the console, describe the tool, and Ada writes and tests it for you. See Build tools with AI, or Build from GitHub to turn your own API’s code into tools.

1. Install the CLI

   macOS / Linux

   curl -fsSL https://platform.glxymesh.com/install.sh | bash

   Windows (PowerShell)

   irm https://platform.glxymesh.com/install.ps1 | iex

   Windows (cmd)

   curl -fsSL https://platform.glxymesh.com/install.cmd -o install.cmd && install.cmd && del install.cmd

   The binary is called gxmesh. It keeps itself current with gxmesh update.

2. Sign in

   gxmesh login

   The CLI shows a URL and a code and tries to open the URL in your browser. Enter the code there and approve. This works over SSH too: open the URL on any machine.

3. Create the project

   A project is one directory on your machine and one MCP server on Glxymesh. Create it, then pick its language; every code tool in the project uses it.

   gxmesh org use                      # pick your organization
   gxmesh project create helpdesk      # create the project on Glxymesh
   mkdir acme-helpdesk && cd acme-helpdesk

   TypeScript

   gxmesh init --lang node --project helpdesk
   npm install                 # fetches @glxymesh/sdk

   Go

   gxmesh init --lang go --project helpdesk

   Python

   gxmesh init --lang python --project helpdesk

   init uses the active organization unless you pass --org. It writes:

   • Directoryacme-helpdesk/

     • gx.yml the project: org, slug, language, defaults
     • package.json packages for every tool, with @glxymesh/sdk (go.mod requiring glxymesh.com/sdk in Go, requirements.txt in Python)
     • tsconfig.json TypeScript only (pyrightconfig.json in Python, for your editor)
     • Directorytools/ one folder per tool, empty for now

       • …
     • .gitignore

   gx.yml

   spec: glxymesh/project@v1
   org: acme
   project: helpdesk
   lang: node
   
   server:
     title: Acme Helpdesk
     description: Support desk tools for Acme agents
   
   defaults:
     timeout: 10s
     memory: 256MB
     output: json

   server.title and server.description are what MCP clients show when they connect; init leaves them commented out until you fill them in. org, project and lang are fixed once set.

4. Add a tool

   gxmesh new list-open-issues

   This creates tools/list-open-issues/ with a tool.yml and a code file in the project’s language. Replace the tool.yml with this:

   tools/list-open-issues/tool.yml

   spec: glxymesh/tool@v1
   name: list-open-issues
   kind: function
   description: >
     Lists open issues in a GitHub repository, newest first.
     Use it to triage or to see what is broken right now.
   read_only: true
   
   inputs:
     owner: {type: string, description: "GitHub user or org, e.g. glxymesh"}
     repo:  {type: string, description: "Repository name, e.g. cli"}
     limit: {type: integer, default: 20, min: 1, max: 100}
   
   output:
     format: toon
     as: issues
   
   network:
     allow: [api.github.com]
   
   tests:
     - input: {owner: golang, repo: go, limit: 2}
       expect: {rows: 2}

   The description is what the model reads to decide when to call the tool, so write it for the model. network.allow lists every host the tool may reach; any other host is refused.

   Then the code:

   TypeScript

   tools/list-open-issues/tool.ts

   import type { Ctx } from '@glxymesh/sdk';
   import type { Input } from './tool.gen';
   
   export async function run(ctx: Ctx, input: Input) {
     const url = `https://api.github.com/repos/${input.owner}/${input.repo}/issues`;
     const res = await ctx.fetch(`${url}?state=open&per_page=${input.limit}`);
     const issues = await res.json();
     return issues.map((i: any) => ({ number: i.number, title: i.title, author: i.user.login }));
   }

   Go

   tools/list-open-issues/tool.go

   package listopenissues
   
   import (
     "encoding/json"
     "fmt"
   
     "glxymesh.com/sdk/glxy"
   )
   
   type issue struct {
     Number int    `json:"number"`
     Title  string `json:"title"`
     User   struct {
       Login string `json:"login"`
     } `json:"user"`
   }
   
   func Run(ctx *glxy.Ctx, in Input) (any, error) {
     url := fmt.Sprintf("https://api.github.com/repos/%s/%s/issues?state=open&per_page=%d",
       in.Owner, in.Repo, in.Limit)
     res, err := ctx.HTTP().Get(url)
     if err != nil {
       return nil, glxy.Errorf("github: %v", err)
     }
     defer res.Body.Close()
     var issues []issue
     if err := json.NewDecoder(res.Body).Decode(&issues); err != nil {
       return nil, glxy.Errorf("github: %v", err)
     }
     rows := make([]map[string]any, len(issues))
     for n, i := range issues {
       rows[n] = map[string]any{"number": i.Number, "title": i.Title, "author": i.User.Login}
     }
     return rows, nil
   }

   Python

   tools/list-open-issues/tool.py

   from glxymesh import Ctx
   from .tool_gen import Input
   
   
   def run(ctx: Ctx, input: Input) -> list[dict]:
       url = f"https://api.github.com/repos/{input['owner']}/{input['repo']}/issues"
       res = ctx.fetch(url, params={"state": "open", "per_page": input["limit"]}).raise_for_status()
       return [{"number": i["number"], "title": i["title"], "author": i["user"]["login"]} for i in res.json()]

   The Input type is generated from inputs, so a renamed input is a compile error (in Python, a type checker’s), not a runtime one. To reach private repositories, bind a GitHub token to api.github.com; see Keys and network access.

5. Run it on your machine

   Call the tool directly:

   gxmesh call list-open-issues '{"owner":"golang","repo":"go","limit":3}'

   It builds the project, runs the tool, and prints the answer, its log lines and every request it sent. Run the tests: from every tool.yml with gxmesh test.

   Local runs apply the same network rules as production: remove api.github.com from network.allow and the call fails with the host it tried to reach. See Develop locally.

6. Deploy

   gxmesh push

   This push lets tools reach more than the live version can:
     host api.github.com
   
   Approve? [y/N] y
   ✓ Live  ·  acme/helpdesk r1  ·  1 test passed

   A push that adds a host or a key asks you to approve it first. Later pushes that don’t change hosts or keys go straight through. The platform builds the project, runs the tests: from your tool.yml, and makes the revision live only if they pass.

7. Connect your client

   gxmesh connect

   It prints your project’s address and client setup instructions. Choose your client below. Replace the example organization and project with the values printed by gxmesh connect.

   Codex

   codex mcp add acme-helpdesk --url https://acme.mcp.glxymesh.com/helpdesk
   codex mcp login acme-helpdesk
   codex

   Approve the browser sign-in. Inside Codex, run /mcp to check the tools, then ask it to list the open issues in golang/go.

   Claude Code

   claude mcp add --transport http acme-helpdesk https://acme.mcp.glxymesh.com/helpdesk

   Inside Claude Code, run /mcp, choose acme-helpdesk → Authenticate, and approve the sign-in page. Then ask Claude: “What are the open issues in golang/go?”

   For VS Code, Cursor and other clients, follow Connect an MCP client.

Note

Commit the whole directory except .env.local and .glxy/, which gxmesh init already put in .gitignore. What you commit is exactly what the platform builds.

Next steps

• Build tools with AI: describe a tool and let Glxymesh write and test it.
• Tool kinds: tools with no code at all.
• Keys and network access: how keys reach APIs without your code holding them.
• Project layout: every file in a project, for each language.
• Connect other clients: Codex, Claude on the web and desktop, VS Code, Cursor and Windsurf.