Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

How to build an MCP server in TypeScript and Python

Build an MCP server with the 2026 TypeScript and Python SDKs: tools, stdio and Streamable HTTP, OAuth, security, Inspector tests and publishing.

iThub Insights cover: Tutorial, How to Build an MCP Server, with the iThub logo tile
On this page
  1. Decide what your server should expose
  2. Step 1: pick an SDK that matches the current protocol
  3. Step 2: write a minimal server in TypeScript
  4. Step 3: write the same server in Python
  5. Step 4: test it with MCP Inspector
  6. Step 5: connect it to a client
  7. Step 6: serve it remotely over Streamable HTTP
  8. Step 7: add authorization to a remote server
  9. Step 8: harden the tools
  10. Step 9: package, version and publish
  11. Checklist before you ship
  12. Common mistakes
  13. Where to go next

To build an MCP server, install an official SDK (@modelcontextprotocol/server for TypeScript or mcp for Python), register the tools, resources and prompts you want to expose, and serve them over stdio for a local client or over Streamable HTTP for a remote one. Before you connect a real client, call every tool with MCP Inspector. This tutorial builds the same small server in both languages, then covers HTTP, authorization, security and packaging.

It is the hands-on companion to our explainer What is an MCP server?, which covers the host, client and server roles. Here the focus is code. The server code, Inspector commands and packaging steps below were run on November 18, 2026 with @modelcontextprotocol/server 2.4.0, the Python mcp package 2.3.0 and MCP Inspector 2.15.0. Client configuration snippets follow each vendor's documentation on that date.

Decide what your server should expose

An MCP server offers three kinds of capability, separated by who decides to use them:

  • Tools Are functions with an input schema that the model decides to call, so they need tight validation and precise descriptions.
  • Resources Are read-only data addressed by a URI, such as a database schema, that the application loads as context.
  • Prompts Are message templates the user picks by name, often shown as slash commands.

The example in this guide is a checksum server: one hash_text tool, one resource listing the supported algorithms and, in Python, one prompt. It needs no network access and no credentials, so every test result can be checked by hand.

When an MCP server is the right choice

An MCP server earns its maintenance cost when several AI clients need the same live capability, with a schema the host can display and calls the user can approve. Weigh the alternatives first:

  • A plain API Remains the right interface for ordinary programs. An MCP server usually wraps an API rather than replacing it.
  • A CLI May already be enough for coding agents that have a shell. A documented command such as gh or kubectl needs no extra process to maintain. MCP adds value when the client has no shell, or when you want typed inputs, per-call approval and one sign-in flow shared across clients.
  • An agent skill Fits when the gap is know-how rather than access: a procedure, a house style, a review checklist. Our guide to how Claude skills work explains the format. The two combine well, with the skill carrying the procedure and the server carrying the connection.

Step 1: pick an SDK that matches the current protocol

The current MCP specification is revision 2026-07-28, and both official SDKs moved to a version 2 line to implement it. The revision makes the protocol stateless: the initialize handshake and protocol-level sessions are gone, every request carries its protocol version, and a server that needs state across calls returns an explicit handle that the client passes back as a tool argument. It also deprecates the Logging, Roots and Sampling features and the old HTTP+SSE transport (2026-07-28 changelog).

The v2 SDKs serve both 2026-07-28 clients and older clients that still open with initialize from the same code. In our tests, Inspector 2.15.0 negotiated 2025-11-25, the Python client negotiated 2026-07-28, and both reached the same tools.

TypeScript Python
Package tested @modelcontextprotocol/server 2.4.0 mcp 2.3.0
Server class McpServer MCPServer (named FastMCP in v1)
Input schema Zod v4 or another Standard Schema library Type hints and Pydantic Field
stdio entry point serveStdio(factory) mcp.run()
HTTP entry point createMcpHandler(factory) mcp.run(transport="streamable-http")
Runtime Node.js 20 or later Python 3.11 or later

Many tutorials still show the v1 APIs: @modelcontextprotocol/sdk in TypeScript and from mcp.server.fastmcp import FastMCP in Python. The TypeScript SDK README says v1 receives bug fixes and security updates for at least six months after the v2 release of July 27, 2026. In Python the old import path was removed rather than deprecated, as the Python SDK documentation explains. The standalone fastmcp package on PyPI is a separate project maintained by Prefect, not the official SDK.

Step 2: write a minimal server in TypeScript

Create a project and install the server package, Zod and tsx, which runs TypeScript without a build step. The SDK ships ES modules only, hence type=module.

mkdir checksum-mcp && cd checksum-mcp
npm init -y
npm pkg set type=module
npm install @modelcontextprotocol/server zod
npm install -D tsx typescript @types/node

Put the server definition in a factory function. The SDK calls it whenever it needs a fresh instance, and the same factory serves stdio now and HTTP later.

// src/checksum.ts
import { createHash } from 'node:crypto';
import { McpServer } from '@modelcontextprotocol/server';
import * as z from 'zod/v4';

const ALGORITHMS = ['sha256', 'sha512', 'sha1'] as const;

export function createServer(): McpServer {
  const server = new McpServer({ name: 'checksum', version: '0.1.0' });

  server.registerTool(
    'hash_text',
    {
      title: 'Hash text',
      description: 'Return the hex digest of a UTF-8 string',
      inputSchema: z.object({
        text: z.string().max(100_000),
        algorithm: z.enum(ALGORITHMS).default('sha256'),
      }),
      annotations: { readOnlyHint: true, openWorldHint: false },
    },
    async ({ text, algorithm }) => {
      const digest = createHash(algorithm).update(text, 'utf8').digest('hex');
      return { content: [{ type: 'text', text: digest }] };
    },
  );

  server.registerResource(
    'algorithms',
    'checksum://algorithms',
    { description: 'Supported hash algorithms', mimeType: 'text/plain' },
    async (uri) => ({ contents: [{ uri: uri.href, text: ALGORITHMS.join('\n') }] }),
  );

  return server;
}

registerTool takes a name, a configuration and an async handler. The Zod schema does three jobs: the SDK converts it into the JSON Schema the model sees, validates arguments before the handler runs and types the handler's parameters. The length limit and the enum are input validation at no extra cost. The annotations tell the client that this tool changes nothing and does not interact with external systems.

Now add the stdio entry point:

// src/stdio.ts
import { serveStdio } from '@modelcontextprotocol/server/stdio';
import { createServer } from './checksum.js';

void serveStdio(createServer);
console.error('checksum server ready on stdio'); // stderr, never stdout

Run npx tsx src/stdio.ts. The banner appears and the process waits on stdin for a client to speak first, which is the expected behavior. Mind the console.error: on stdio, stdout is the protocol channel, and a single console.log corrupts the JSON-RPC stream.

Step 3: write the same server in Python

Install the SDK with its CLI extra, preferably inside a virtual environment:

pip install "mcp[cli]"   # or: uv add "mcp[cli]"

The Python version adds a prompt to show the third primitive:

# server.py
import hashlib
from typing import Annotated, Literal

from pydantic import Field
from mcp.server import MCPServer
from mcp.types import ToolAnnotations

mcp = MCPServer("checksum", version="0.1.0")


@mcp.tool(annotations=ToolAnnotations(read_only_hint=True, open_world_hint=False))
def hash_text(
    text: Annotated[str, Field(max_length=100_000)],
    algorithm: Literal["sha256", "sha512", "sha1"] = "sha256",
) -> str:
    """Return the hex digest of a UTF-8 string."""
    return hashlib.new(algorithm, text.encode("utf-8")).hexdigest()


@mcp.resource("checksum://algorithms")
def algorithms() -> str:
    """Supported hash algorithms."""
    return "sha256\nsha512\nsha1"


@mcp.prompt()
def verify_download(file_name: str, expected: str) -> str:
    """Ask the model to compare a published checksum with a computed one."""
    return f"Hash {file_name} with hash_text and compare it to {expected}."


if __name__ == "__main__":
    mcp.run()

Here the function signature is the schema. Literal becomes an enum, Field(max_length=...) becomes a length limit and the docstring becomes the description. MCPServer validates arguments with Pydantic before your function runs, so a call with algorithm="md5" returns an error result that names the allowed values, which the model can read and correct. Because the function declares -> str, the SDK also publishes an output schema and returns structuredContent next to the text block.

mcp.run() defaults to stdio. For diagnostics, use the logging module, which writes to stderr. The Python SDK guide to running a server notes that the SDK diverts flushed stdout writes to stderr while serving, but anything printed before serving starts still lands on the protocol channel.

Step 4: test it with MCP Inspector

MCP Inspector, the project's official tool for testing servers, has a web UI and a CLI. The CLI is the faster check and the one to keep in CI. Everything before -- is the server command, everything after it is an Inspector option:

npx @modelcontextprotocol/inspector --cli npx tsx src/stdio.ts -- --method tools/list
npx @modelcontextprotocol/inspector --cli python server.py -- --method tools/call --tool-name hash_text --tool-arg text=hello

The second command printed the SHA-256 of hello, matching sha256sum:

"text": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

Drop --cli and the Inspector opens its web UI at http://127.0.0.1:6274, guarded by a token printed at launch, with tabs for tools, resources and prompts. According to the Inspector documentation, version 2 needs a current Node.js 22, 24 or 26 patch release, and a tools/call that returns isError exits with code 5, so a failing tool breaks a CI job.

Work through each primitive the way a client will:

  1. List the tools and read each schema as the model will see it.
  2. Call each tool with valid input, invalid input and edge cases such as an empty string or the maximum length.
  3. Read every resource and fetch every prompt with sample arguments.
  4. Watch stderr for warnings and stack traces.

--tool-arg parses values as JSON when it can, so id=012 stays a string but id=10001 becomes a number. Use --tool-args-json when you need exact types. The reference MCP Everything Server, which exercises every primitive, is a useful comparison point.

Step 5: connect it to a client

Every client launches a stdio server from a command and its arguments; only the configuration file differs. Use absolute paths, because a client starts your server from its own working directory, not from your shell. The Python SDK's guide to connecting a real host calls a relative path the most common failure.

In Claude Code, options go before the server name and everything after -- is the launch command:

claude mcp add checksum -- npx tsx /absolute/path/to/checksum-mcp/src/stdio.ts
claude mcp add --transport http checksum-remote http://127.0.0.1:3000/mcp

The default scope is the current project. --scope project writes the entry to a shareable .mcp.json instead, and /mcp inside a session shows each server's status and handles OAuth sign-in (Claude Code MCP documentation).

Cursor and Claude Desktop read the same mcpServers shape:

{
  "mcpServers": {
    "checksum": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/checksum-mcp/src/stdio.ts"]
    }
  }
}
  • Cursor Reads .cursor/mcp.json in the project or ~/.cursor/mcp.json for every project. Remote servers use url and optional headers, and values can reference environment variables with ${env:NAME} (Cursor MCP docs).
  • Claude Desktop Reads claude_desktop_config.json from ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows. Quit the app fully and reopen it after each edit. For Python servers, mcp install server.py writes the entry for you.
  • VS Code Points new Copilot configurations to the same portable mcpServers format, in a workspace-root .mcp.json or the Copilot user file ~/.copilot/mcp-config.json, with each entry declaring "type": "stdio" or "type": "http". The older .vscode/mcp.json file with a servers key belongs to the Local harness, which the VS Code MCP configuration reference says will be removed in February 2027.

When a client does not list your tools, run the launch command by hand first: it should print the banner on stderr and wait. Then check the client's logs: Claude Desktop writes each server's stderr to mcp-server-<name>.log under ~/Library/Logs/Claude on macOS or %APPDATA%\Claude\logs on Windows, and Cursor shows connection and tool-call logs under Output > MCP Logs.

Step 6: serve it remotely over Streamable HTTP

A stdio server belongs to one client on one machine. To share it or host it as a service, use Streamable HTTP, the protocol's single-endpoint HTTP transport.

stdio Streamable HTTP
Who starts the server The client, as a child process You, as a long-running service
Clients per server process One Many
Credentials Environment variables OAuth 2.1 bearer tokens
Network exposure None One endpoint, usually /mcp
Logging stderr only, stdout carries the protocol Ordinary application logs
Typical use Local files, developer tools, CLIs Shared, hosted or multi-user services

In TypeScript, install @modelcontextprotocol/node and add a second entry point that reuses the factory:

// src/http.ts
import { createServer as createHttpServer } from 'node:http';
import { createMcpHandler } from '@modelcontextprotocol/server';
import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from '@modelcontextprotocol/node';
import { createServer } from './checksum.js';

const mcp = toNodeHandler(createMcpHandler(createServer));
const checkHost = localhostHostValidation();
const checkOrigin = localhostOriginValidation();

createHttpServer((req, res) => {
  if (!checkHost(req, res) || !checkOrigin(req, res)) return;
  void mcp(req, res);
}).listen(3000, '127.0.0.1', () => console.error('MCP endpoint: http://127.0.0.1:3000/mcp'));

createMcpHandler builds a fresh server instance per request and keeps nothing between requests, so keep connection pools and caches at module scope. The handler checks no Host header, no Origin header and no token, which is why the two guards run first: they block DNS rebinding, where a malicious web page points its own domain at 127.0.0.1. In our test, requests with a foreign Host or Origin both received 403. The TypeScript SDK HTTP guide shows the Express, Fastify and Hono equivalents, which arm both checks by default on localhost.

In Python, replace the last line of server.py:

mcp.run(transport="streamable-http", host="127.0.0.1", port=8000)

The endpoint is http://127.0.0.1:8000/mcp. On localhost the SDK turns on DNS-rebinding protection by default; our test got 421 for a foreign Host and 403 for a foreign Origin. Behind a real hostname, that same default rejects every request until you pass transport_security with the hosts you actually serve.

Test either endpoint with the Inspector CLI:

npx @modelcontextprotocol/inspector --cli --transport http --server-url http://127.0.0.1:3000/mcp --method tools/list

The specification requires servers to validate the Origin header and recommends binding only to 127.0.0.1 when running locally (transports). The older HTTP+SSE transport has been deprecated since revision 2025-03-26: the TypeScript v2 server no longer serves it outside a frozen legacy package, and the Python SDK still accepts transport="sse" but advises against building on it. Use Streamable HTTP for new remote servers.

Step 7: add authorization to a remote server

Authorization is optional in MCP, and the rules depend on the transport. A stdio server should not run an OAuth flow; it reads credentials such as an API key from its environment. An HTTP server that adds authorization should follow the authorization specification, in which your MCP server is an OAuth 2.1 resource server: it verifies tokens that a separate authorization server issued and never issues them itself. The TypeScript SDK documentation recommends a dedicated identity provider for that role.

A protected server has five jobs:

  1. Publish OAuth 2.0 Protected Resource Metadata (RFC 9728), which tells clients where your authorization server lives.
  2. Answer a missing or invalid token with 401 and a WWW-Authenticate header whose resource_metadata parameter points to that document.
  3. Validate every token, including its audience. The specification requires servers to accept only tokens issued for them, using the resource indicator from RFC 8707.
  4. Never pass the client's token to a downstream API. If your tools call another service, obtain a separate credential for it; the specification forbids accepting or forwarding tokens meant for other resources.
  5. Require the smallest scopes that cover each operation and answer 403 with insufficient_scope when a token lacks one.

For client registration, revision 2026-07-28 prefers Client ID Metadata Documents and deprecates Dynamic Client Registration, which stays only for compatibility. Both SDKs provide the resource-server side: requireBearerAuth with an expectedResource audience check in TypeScript, and the token_verifier and auth settings of MCPServer in Python.

Step 8: harden the tools

The specification's tool section says servers must validate all tool inputs, implement access controls, rate limit tool invocations and sanitize tool outputs. In practice that means:

  • Validate meaning, not only shape. A schema confirms that path is a string; your code must confirm it resolves inside an allowed directory, that a record ID belongs to the caller and that a URL does not point at an internal address. MCPServer rejects path traversal, absolute paths and null bytes in resource template parameters by default, and the TypeScript McpServer accepts an optional maxToolInputElements limit for oversized arrays and objects.
  • Grant the least privilege. Request narrow token scopes, keep tools read-only unless writing is the point, and split destructive operations into their own tools. The reference MCP Filesystem Server shows the pattern: it only works inside directories you explicitly allow.
  • Keep secrets out of the protocol. Read keys from environment variables and never echo them in descriptions, results, errors or logs.
  • Treat tool output as untrusted input to the model. A fetched web page, ticket or email can contain instructions aimed at the model. Return structured data, label third-party content, and never let a tool result trigger a privileged action without user confirmation.
  • Use annotations honestly, then enforce in code. readOnlyHint, destructiveHint, idempotentHint and openWorldHint help a client decide what to auto-approve, but the specification tells clients to treat annotations as untrusted unless the server is trusted. They are hints, not controls.
  • Return useful errors without internals. A short isError explanation lets the model retry. In the Python SDK, only the message of a ToolError raised in a tool reaches the model; other exceptions read Error executing tool <name>, with the traceback kept in your logs.
  • Bind state handles to users. If a tool returns an ID that later calls pass back, generate it randomly and check on every call that it belongs to the authenticated caller.

The OWASP GenAI Security Project's practical guide for secure MCP server development, published in February 2026, expands on architecture, authentication, validation and deployment hardening.

Step 9: package, version and publish

Users should be able to start your server with one command. For TypeScript, compile to JavaScript, add #!/usr/bin/env node as the first line of src/stdio.ts and declare a bin entry:

{
  "name": "checksum-mcp",
  "version": "0.1.0",
  "type": "module",
  "bin": { "checksum-mcp": "dist/stdio.js" },
  "files": ["dist"],
  "mcpName": "io.github.your-name/checksum"
}

Compile with tsc (rootDir set to src, outDir to dist) and publish. Users then launch it with npx -y checksum-mcp. We checked this by packing the project and running the tarball through npx under the Inspector.

For Python, wrap mcp.run() in a main() function and expose it as a console script:

[project]
name = "checksum-mcp"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = ["mcp>=2.3,<3"]

[project.scripts]
checksum-mcp = "checksum_mcp.server:main"

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

After publishing to PyPI, uvx checksum-mcp downloads and runs it in an isolated environment. For a container, install the wheel in a small image and give the client docker run -i --rm checksum-mcp:0.1.0 as the launch command; -i keeps stdin open for the protocol:

FROM python:3.12-slim
COPY dist/*.whl /tmp/
RUN pip install --no-cache-dir /tmp/*.whl && rm /tmp/*.whl
USER nobody
ENTRYPOINT ["checksum-mcp"]

The MCP Registry, still in preview, stores metadata only: publish the package first, then run mcp-publisher init, mcp-publisher login github and mcp-publisher publish. The registry verifies ownership through the mcpName field on npm, an mcp-name: line in the README on PyPI or an io.modelcontextprotocol.server.name label on container images. Remote-only servers can publish their endpoint URL without a package.

Three version numbers are in play:

  • The package version Follows semantic versioning. Renaming or removing a tool, or changing its input schema incompatibly, is a major change.
  • The server version Passed to the constructor identifies the server to clients; keep it equal to the package version. Registry versions are immutable once published.
  • The protocol revision Is a date such as 2026-07-28. The SDK negotiates it with each client, so pin the SDK's major version (mcp>=2.3,<3) rather than the protocol.

Checklist before you ship

  1. Every tool has a specific name, a description that says when to use it and a schema with limits.
  2. Invalid input returns an isError result the model can act on.
  3. Nothing but protocol messages reaches stdout on stdio.
  4. Inspector CLI calls for each tool run in CI and fail the job on errors.
  5. Destructive tools are separate, annotated and protected by checks in code.
  6. Secrets come from the environment and never appear in results or logs.
  7. HTTP endpoints validate Host and Origin, bind to localhost in development and allow-list hostnames in production.
  8. Remote servers check token audience and scopes and never forward client tokens.
  9. Client configuration uses absolute paths and has been tested in every client you support.
  10. The package, server and registry versions match.

Common mistakes

  • Copying v1 code. FastMCP imports, @modelcontextprotocol/sdk and hand-wired transports come from older tutorials. The official build-a-server tutorial notes that a TypeScript server wired with server.connect(new StdioServerTransport()) only serves 2025-era clients, while serveStdio serves both.
  • Relying on sessions. Revision 2026-07-28 removed protocol sessions. Store cross-call state in your own storage behind an explicit handle.
  • Binding to 0.0.0.0 without a host allow-list. That exposes a development server to your network and disables the localhost defaults.
  • Exposing every API endpoint as a tool. Every tool definition goes to the model, and overlapping tools lead it to pick the wrong one. Fewer, task-shaped tools work better.

Where to go next

Published servers are useful references for tool design. Chrome DevTools MCP is Google's official server for browser debugging, and HA-MCP puts Home Assistant control behind safety modes. Browse the MCP server hub, the best MCP servers by workflow and the MCP servers for Claude Code collection, or search the full iThub directory for the services your server will connect to.

Frequently asked questions

Should I build my MCP server in TypeScript or Python?

Use the language of the system you are wrapping. Both official SDKs implement the same protocol revision and the same three primitives, and clients cannot tell which one you used. The TypeScript SDK takes Zod or another Standard Schema library for inputs and runs on Node.js, Bun and Deno. The Python SDK builds schemas from type hints and needs Python 3.11 or later.

Can an MCP server keep state between tool calls?

Not through the protocol. Revision 2026-07-28 removed protocol sessions, so every request stands alone. Keep state in your own database or cache, return an ID from the tool that creates it and have later calls pass that ID as an argument. Generate IDs randomly and check that each one belongs to the authenticated caller.

Is SSE still supported for MCP servers?

Only for compatibility. The HTTP+SSE transport has been deprecated since revision 2025-03-26, and revision 2026-07-28 places it under a formal deprecation policy with a minimum twelve-month window before removal. Some clients still connect to SSE servers, but new remote servers should use Streamable HTTP.

Why does my MCP server run in a terminal but not in Claude Desktop?

The usual causes are a relative path, a missing environment variable or stray output on stdout. Claude Desktop starts servers from its own working directory with its own environment, so give absolute paths to both the interpreter and the script, pass keys in the env block and fully quit and reopen the app after editing its config. The per-server log file shows what your server wrote to stderr.

Do I need OAuth for my MCP server?

Not for a local stdio server, which reads credentials from its environment. A remote server that exposes private data or actions should require tokens. The MCP authorization specification describes the model: your server accepts only OAuth 2.1 access tokens issued for it by a separate authorization server, and it publishes metadata that tells clients where to sign in.

How many tools should one MCP server expose?

As few as the job needs. Clients pass tool names, descriptions and schemas to the model, so a long list costs context and similar tools are easy to confuse. Shape tools around user tasks instead of mirroring every API endpoint, and keep read and write actions apart so clients can approve them differently.

Do I have to publish my server to the MCP Registry?

No. Clients can launch any package or connect to any URL you configure. The registry, still in preview, helps people find your server: it stores metadata that points to your npm, PyPI or container package or to your remote endpoint, and it verifies that you own the namespace you publish under.

Tools in this article

  1. MCP Everything ServerA reference test server for MCP client builders, demonstrating protocol features such as tools, resources and prompts.MCP Servers0 views
  2. MCP Filesystem ServerA local file connector for reading, editing, searching and organizing files inside explicitly allowed directories.MCP Servers1 views
  3. Chrome DevTools MCPOfficial MCP server and CLI from the Chrome DevTools team that lets coding agents automate and debug ChromeMCP Servers0 views
  4. HA-MCPCommunity MCP server that lets Claude, ChatGPT and other AI clients configure, automate and debug Home AssistantMCP Servers1 views
Share this article

Facts link to their official sources. Product details can change after publication: report an error or read the editorial methodology.

Emanuel DE ALMEIDA

Written by

Emanuel DE ALMEIDA

Entrepreneur · IT consultant · Software creator

Geneva-based entrepreneur, IT consultant and creator of SuniPDF and SuniCapture. Emanuel shares practical IT, cybersecurity and software insights on iThub.

Keep reading

More guides and analysis from the iThub editors.

All insights
What is an MCP server? A practical guide to AI connectionsLearn what an MCP server does, how tools and resources connect to AI clients, and how to choose a maintained integration for a practical workflow.What is Domain Rating (DR)? How it works and how to use itDomain Rating (DR) is Ahrefs' 0 to 100 score for a site's backlink strength. How it is calculated, how it differs from DA, and why Google does not use it.Is submitting your software to directories worth it in 2026?What software directory submission brings in 2026: referral visits, mentions, link attributes, how to vet a directory, write a listing and measure results.