Public · Read only · No key

MCP Server

Eyes on Flash runs an MCP server that lets an SI assistant look up the sourced figures behind its timelines, the Bit Market, and the Fab Tracker. It has no account and no key, and every record it returns carries the public source it was read from.

Connect a client Try it with curl

What the server is

The server answers at one address, https://eyesonflash.com/mcp, over the Streamable HTTP transport of the Model Context Protocol. Every message is an HTTP POST to that address. The server keeps no sessions and opens no stream back to the client, so a plain GET gets the 405 the protocol allows. It reads only and changes nothing.

It searches 16 datasets that cover NAND, DRAM, and HBM dies, SSD controllers, hard drives, storage standards, memory company results, and fab sites. Figures that came from paid analyst reports, teardown services, or third-party press are left out, and the launch article explains the rule.

Connect a client

Claude

In Claude on the web or the desktop app, open Customize, then Connectors. Choose + Add, then Add custom connector. Enter a name, paste https://eyesonflash.com/mcp as the server URL, and continue. Under Authentication choose No sign in, then click Add. To use it in a chat, click the + button at the lower left of the chat, choose Connectors, and switch it on. Anthropic’s page on custom connectors has the current steps and says which plans can add one. On a team plan, an owner adds it.

Claude Code

One command adds the server. The name eof is only a label, so any name works.

claude mcp add --transport http eof https://eyesonflash.com/mcp

Run claude mcp list to see its status, or /mcp inside a session. The Claude Code MCP guide covers the --scope option, which sets whether the server is yours alone, shared with a project, or available in every project.

Other clients

Clients that read a JSON server list can take the same address. The field names differ between clients, so check yours. This is the shape Claude Code reads from a project’s .mcp.json file.

{
  "mcpServers": {
    "eof": { "type": "http", "url": "https://eyesonflash.com/mcp" }
  }
}

The three tools

Each tool is marked read only. An argument the tool does not list is refused with an error instead of being ignored.

The three tools: name, arguments, and what each returns
Tool	Arguments	What it returns
`list_datasets`	none	Names the 16 datasets the server searches, with the record count of each and the page on this site that shows it.
`search_records`	query (required), dataset, limit, offset	Finds records that contain every word in the query, such as a maker, a part, a measure, a company, or a quarter. Returns up to 50 records a call, each with its source link and an Eyes on Flash cite.
`get_record`	dataset and id (both required)	Returns every figure for one record, picked by its record_id, site_id, company, or claim_id within one dataset.

search_records takes a query of up to 200 characters, an optional dataset from the list that list_datasets returns, a limit from 1 to 50 (10 if omitted), and an offset from 0 to 10,000 for paging. get_record takes a dataset and an id of up to 120 characters.

A record holds a value, its unit, its date, the name of the publisher, and the link to where it was published. The data files behind the pages hold the words each figure was read from, and the server strips them. Here is one record from the call below, trimmed to the fields that matter.

{
  "dataset": "nand-die-timeline",
  "maker": "Kioxia",
  "measure": "layers",
  "value": 218,
  "source_publisher": "Kioxia",
  "source_url": "https://kioxia.com/en-jp/rd/technology/topics/topics-66.html",
  "cite": "Eyes on Flash, NAND Die Timeline, https://eyesonflash.com/timelines/nand-die/"
}

Try it with curl

MCP starts with a handshake, so a lone tools/call is not the whole protocol. A client sends initialize, then a notifications/initialized notification, and only then calls tools. This server keeps no state between requests, so the handshake does not change what it answers, but a client should still follow the sequence. Every request sends Accept: application/json, text/event-stream, which the Streamable HTTP transport requires of a client, and every request after the first sends the protocol version in an MCP-Protocol-Version header. The server speaks 2025-11-25, 2025-06-18, and 2025-03-26.

1. Initialize

curl -s https://eyesonflash.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

The reply names the server (eyes-on-flash), repeats the protocol version it will use, and carries short instructions that ask callers to cite Eyes on Flash and the source on each record.

2. Send the initialized notification

curl -s -i https://eyesonflash.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{"jsonrpc":"2.0","method":"notifications/initialized"}'

A notification has no reply. The server answers 202 Accepted with an empty body.

3. Call a tool

curl -s https://eyesonflash.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"search_records","arguments":{"query":"Kioxia BiCS8 layers","limit":1}}}'

The answer is a JSON-RPC result. The records are in result.structuredContent.records, and the same JSON arrives as text in result.content. Pipe the output through jq to format it.

Use list_datasets with empty arguments to see the dataset names, or call get_record with a record_id from a search.

Limits

Each address gets 60 requests a minute. Past that, the server answers 429 with a Retry-After header.
Cloudflare also blocks more than 6 requests in 10 seconds from one address, for 10 seconds, with its own 429 before the server runs. Pace a script, because several quick curl commands in a row can trip it.
A search returns at most 50 records. Page through more with offset.
A request body over 16KB is refused.
An unknown tool argument is refused with an error.

The launch article explains why the limits exist and how the server runs on Cloudflare’s Free plan.

Terms

You can use what the server returns in your own work, with a cite to Eyes on Flash and to the source named on the record. Everything comes as is, with no warranty, and no company in the data endorses this site. The full wording is in the Terms of Use.