Free tools Windows power users keep installed
One-click scans. No signup required.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
The jonigl/mcp-server-with-streamable-http-example repository is a runnable Python teaching example of an MCP server using Streamable HTTP. Run it with python simple_streamable_http_mcp_server.py; it listens on port 8000 by default. The example exposes tools, a prompt, and resources, making it useful for seeing several MCP primitives together—not a hosted service or a production deployment blueprint.
What the Streamable HTTP example demonstrates
The repository named jonigl/mcp-server-with-streamable-http-example demonstrates a Python server that communicates using MCP’s Streamable HTTP transport. Its README describes a compact learning project, not a managed endpoint: you run the server locally and inspect the capabilities it offers.
The example is useful when you want to see how a server can expose three MCP building blocks: tools that perform actions, a prompt that provides a reusable prompt template, and resources that provide context or data. It is not just a single-tool “hello world” server.
Tools
The README lists these six tools:
hello_world(name)add_numbers(a, b)random_number(min_val, max_val)return_json_example()calculate_bmi(weight, height)get_logo()
The names suggest a range of basic demonstrations, from accepting arguments to returning structured or visual content. Treat them as examples to inspect and learn from; the README’s tool list alone does not establish production guarantees, input validation behavior, or a particular response format for every tool.
#1 Best Overall
Prompt and resources
The listed prompt is BMI Calculator. The resources include server://info, text://welcome, images://ollmcp-logo, and the file://{path*} local-text-file resource template. The file template is a notable part of the example to examine carefully: a local-file resource can expose data from the machine running the server, so review its implementation and access boundaries before adapting it for a shared or remotely reachable deployment.
Run the Python server
The README documents two ways to launch the example. Use the direct Python command if you are running the script, or the documented uv invocation if that is how you run the project. The exact dependency installation steps are not established here, so follow the repository README for its prerequisites and setup rather than guessing package commands.
- Obtain the repository
jonigl/mcp-server-with-streamable-http-exampleand follow its README’s prerequisites and installation instructions. - Start the script from the project environment with
python simple_streamable_http_mcp_server.py. - Alternatively, launch via uv with
uv run mcp-server, as documented by the README. - Check the configured port and use an MCP client compatible with the example’s transport to connect. The default listening port is
8000.
The documented run commands tell you how to start the server, but they do not by themselves specify a complete client setup or establish every detail of the HTTP endpoint and session lifecycle. For those details, inspect the example implementation and its current README.
Change the port or enable debug logging
Set environment variables before starting the process. The README documents MCP_SERVER_PORT for choosing another port and MCP_DEBUG=1 for debug logging. For example, on a Unix-like shell:
MCP_SERVER_PORT=9000 MCP_DEBUG=1 python simple_streamable_http_mcp_server.pyThis starts the script with port 9000 selected and debug logging enabled. You can set either variable independently; the documented default port is 8000.
What to inspect while learning
A productive way to learn from a small server is to trace each advertised capability from registration to its handler or resource implementation. In this example, compare how a tool receives arguments with how the prompt is represented and how a resource URI is resolved. That will make it easier to distinguish a callable action from context supplied to a client.
- Check which names are registered and whether their argument names match the README.
- Follow how tool results are formed, especially for
return_json_example()andget_logo(). - Trace how the
file://{path*}template maps a requested URI to local text, and establish what paths it can serve. - Look at startup configuration and logging behavior before changing the port or deploying beyond a local development environment.
These are inspection tasks, not claims that the sample includes authentication, authorization, production-grade logging, or defenses for every deployment scenario. Those properties need to be established from the code and the environment in which you run it.
How it compares with official TypeScript and Go examples
If you are choosing a language rather than studying this specific Python repository, the official MCP SDKs offer runnable starting points too. The TypeScript SDK provides server and client libraries, Streamable HTTP transport, optional Node.js, Express, and Hono middleware, plus runnable examples. Its quick start runs simpleStreamableHttp.ts from the examples packages. The Go SDK’s HTTP example includes both a server and a client.
| Example | Language and run path | Documented coverage | Best fit |
|---|---|---|---|
| Python repository example | Python; python simple_streamable_http_mcp_server.py or uv run mcp-server |
Streamable HTTP; tools, a prompt, resources; configurable port and debug logging | Learning several MCP primitives in a compact Python project |
| Official TypeScript SDK | TypeScript; quick start runs simpleStreamableHttp.ts from the examples packages |
Server and client libraries, Streamable HTTP, optional Node.js, Express, and Hono middleware, and runnable examples | Building with the TypeScript SDK or choosing among its documented middleware options |
| Official Go SDK HTTP example | Go; go run . server and, in a second process, go run . client |
Server and client; the server exposes a cityTime tool, and the client lists tools and calls it for cities including New York City, San Francisco, and Boston |
Trying the documented Go server-and-client flow |
The Go example documents a default server address of http://localhost:8000. That is the Go example’s documented address; do not assume it establishes the Python example’s full endpoint path or session behavior. The examples also differ in what they demonstrate: the Python README lists tools, a prompt, and resources, while the Go example highlights a client calling a tool.
Streamable HTTP versus older HTTP+SSE guidance
MCP transport advice is version-sensitive. Microsoft’s beginner material describes its Java lesson as using legacy HTTP+SSE and says new remote servers should use the 2026-07-28 Streamable HTTP transport after verifying SDK support. This is a qualification, not a guarantee that every SDK version already supports that specification revision. Before choosing a transport for a new remote server, check the MCP specification revision and the support provided by the exact SDK version you plan to deploy.
The Python repository is explicitly described as a Streamable HTTP example. That makes it relevant for learning the newer transport approach, but does not settle whether its dependencies implement a particular later specification revision. Confirm that against the project’s current code and package versions.
Production checks before exposing a server
The example is presented as educational and runnable. The documented capabilities and launch settings do not establish a hardened deployment configuration. Before making a server reachable by other machines or users, verify its behavior and add the controls your environment requires.
- Access: establish whether the server is bound only to local interfaces or reachable externally, and provide authentication and authorization appropriate to the callers.
- Resource scope: audit the local-file resource template and restrict access to intended files. Do not treat a URI template as a security boundary without verifying its implementation.
- Transport compatibility: confirm the specification revision, SDK support, endpoint behavior, and session handling expected by your clients.
- Configuration: set the listening port deliberately and avoid enabling debug output in an environment where its logs could disclose sensitive information.
- Operations: decide how the process is supervised, how failures are noticed, and what logs are retained. These operational guarantees are not established by the README’s feature list.
Troubleshooting the documented run path
The server does not start with the Python command
Confirm that you are in the project environment and that you followed the repository’s prerequisite and dependency instructions. The documented command assumes the script and its dependencies are available. If you use uv, use the README’s uv run mcp-server command rather than assuming the direct script invocation and project entry point are interchangeable in every setup.
The expected port is unavailable
The example defaults to port 8000. If another process already uses that port, set MCP_SERVER_PORT to an available port, for example MCP_SERVER_PORT=9000, and configure the client to reach the server on the same port.
Debug messages are missing
The documented switch is MCP_DEBUG=1. Set it in the server process environment before launch. If you combine it with a port change, set both variables as shown above.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →A client cannot connect or does not see the listed capabilities
Check that the client supports Streamable HTTP, is pointed at the running server rather than a different example, and uses the endpoint and session behavior implemented by the current repository version. The documented run instructions establish the port, not a complete client URL or a particular client configuration; inspect the code and README for those details.
Or skip the browser setup
ScreenshotNeo is not an MCP server and does not replace this example. It is a separate way to capture a public web page when you need a screenshot of documentation, a hosted demo, or another browser-accessible page. Its screenshot API can return an image or PDF; see the ScreenshotNeo API documentation for request options.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server offers take_screenshot, get_page_info, and capture_pdf for AI agents. The free plan includes 1,000 shots a month without a card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan to get 1,000 screenshots a month with no card.
Recommended Free Tools
Frequently Asked Questions
Does this repository host a public MCP endpoint?
No. It is a locally run educational server example, not a hosted service.
Can I use the Python example’s tools without an MCP client?
The documented interface is an MCP server; the material here does not establish a separate direct-call interface for the tools.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
