mcp-ps-store

MCP server that exposes a PlayStation Network account's own gaming history — playtime, trophy progress, purchased library — so an AI assistant can recommend games from real data instead of guesswork.

Русская версия: README.ru.md.

About

PSN has no public API. This server talks to the same internal API the PlayStation mobile app uses, authenticating with an NPSSO cookie taken from a browser session. Every request is a read; nothing is ever written back to the account.

The layout follows a layered architecture: an API layer (MCP tools), a core layer (services, repositories, DTOs), a DI container and an infrastructure layer.

Core technologies

• Language: Python 3.11+

• Protocol: Model Context Protocol (mcp)

• HTTP client: httpx (async)

• DI container: dependency-injector

• Settings: pydantic-settings

• Dependency management: Poetry

• Testing: Pytest, pytest-asyncio

Related MCP server: PersonalizationMCP

What it exposes

Plus a recommend_games prompt — a ready-made "build my profile and recommend games" scenario that takes an optional steer such as "something short" or "co-op for two".

Quick start

Python 3.11+ is required.

1. Install

With Poetry:

poetry install

Or with a plain virtualenv:

python3.11 -m venv .venv && .venv/bin/pip install -e .

2. Sign in to PSN

1. Sign in at https://www.playstation.com in a browser.

2. Open https://ca.account.sony.com/api/v1/ssocookie — it returns {"npsso":"..."}.

3. Copy the 64-character npsso value and run:

poetry run psn-login PASTE_NPSSO_HERE

Tokens go to ~/.mcp-ps-store/tokens.json with 0600 permissions.

About session lifetime. The access token lives an hour and the refresh token only ten days, but the NPSSO itself lives about two months. The NPSSO is therefore stored next to the tokens, and the server re-authenticates on its own when the refresh token dies. In practice one psn-login lasts about 60 days.

3. Check it works

poetry run psn-doctor

It prints the account name, how many games are visible and the top five by hours.

Connecting a client

Claude Code

claude mcp add ps-store -- /path/to/mcp-ps-store/.venv/bin/python -m app.main

Claude Desktop

In claude_desktop_config.json:

{
  "mcpServers": {
    "ps-store": {
      "command": "/path/to/mcp-ps-store/.venv/bin/python",
      "args": ["-m", "app.main"],
      "cwd": "/path/to/mcp-ps-store"
    }
  }
}

Codex CLI

Codex speaks stdio to local MCP servers, so it works the same way. Either run codex mcp add, or add this to ~/.codex/config.toml:

[mcp_servers.ps-store]
command = "/path/to/mcp-ps-store/.venv/bin/python"
args = ["-m", "app.main"]
cwd = "/path/to/mcp-ps-store"

Check it with /mcp inside a Codex session.

ChatGPT

ChatGPT cannot launch a local process. Custom connectors are added in Developer mode (Settings → Apps → Advanced) and must be a public HTTPS endpoint speaking SSE or Streamable HTTP. So the server has to be switched to HTTP transport and published:

PSN_MCP_TRANSPORT=streamable-http PSN_MCP_PORT=8000 poetry run mcp-ps-store

Then expose http://127.0.0.1:8000/mcp over HTTPS — with OpenAI's Secure MCP Tunnel, or a tunnel such as cloudflared / ngrok — and add the resulting URL as a custom connector.

This publishes your PSN history to whoever finds the URL. The server has no authentication of its own, so put the tunnel behind auth, keep it running only while you need it, and prefer Codex CLI if a local client will do.

Configuration

All settings are read from the environment or a .env file (see .env.example).

Limitations

• Playtime exists only for PS4 / PS5 / PC versions. PSN reports PS3 and Vita games with trophies only, so they appear with hours: null.

• There is no PS Store catalogue here. The store is entirely client-side, and its GraphQL API only accepts persisted queries whose hashes Sony rotates on every deploy — keeping that working is not realistic. Recommendation candidates come from the model's own knowledge of games, while psn_owned_games stops it suggesting something already bought.

• The purchased library goes through PSN's private GraphQL API. If Sony changes the query, that one tool stops working; everything else keeps running and the digest gains a backlog_unavailable note.

• Playtime and trophies are joined by title, so a re-release can merge with the original when they share a trophy set. Editions, platform suffixes and roman numerals are normalised away on purpose — Alan Wake II and Alan Wake 2 are one game.

• The API is unofficial: Sony can change it at any time.

Project structure

.
├── app/
│   ├── api/              # MCP layer: tools, prompts, serialisers, tool errors
│   │   ├── games/
│   │   ├── profile/
│   │   └── taste/
│   ├── core/             # Business logic: services, repositories, DTOs
│   │   ├── auth/         # NPSSO -> tokens, refresh, re-login
│   │   ├── games/        # Library, playtime/trophy merge, name normalisation
│   │   ├── profile/      # Account profile and trophy summary
│   │   └── taste/        # Taste digest aggregation
│   ├── di/               # DI containers and providers
│   ├── infra/adapters/   # HTTP client, token storage, TTL cache
│   ├── cli.py            # psn-login, psn-doctor
│   └── main.py           # MCP server entry point
├── settings/             # pydantic-settings configuration
├── tests/
│   ├── core/             # Merge and aggregation tests
│   └── factories/        # Builders for test data
└── pyproject.toml

Development

poetry run pytest        # unit tests; no network and no account needed
poetry run psn-doctor    # live check against the signed-in account