Skip to main content
Glama

yokatlas-mcp-server

A Python MCP server exposing YÖK ATLAS "tercih kılavuzu" (preference guide) reference-data tools: provinces, universities, and program groups (each tagged with its exam score type). Built on FastMCP with pydantic-settings config, a standard {ok, data, error} tool envelope, and a rate-limited HTTP client with retries.

⚠️ Sorumluluk Reddi Beyanı (Disclaimer)

Bu proje tamamen deneysel amaçlarla oluşturulmuştur. Yapay zeka modelleri hata yapabilir; bu sunucunun ürettiği hiçbir sonuç %100 doğru veya güncel olarak kabul edilmemelidir. Hangi okulu veya bölümü seçeceğinize karar verirken mutlaka bir rehber öğretmen, eğitim danışmanı veya alanında uzman bir kişiden profesyonel destek alın.

Bu proje, yalnızca puanınıza göre hangi okul/bölümlerin mevcut olabileceği konusunda size bir fikir vermek amacıyla oluşturulmuştur; resmî bir tercih/danışmanlık aracı değildir. Burada elde ettiğiniz sonuçları her zaman resmî YÖK ATLAS verileriyle karşılaştırıp doğrulayın.

Bu proje ve geliştiricisi, bu sunucunun ürettiği bilgilere dayanılarak yapılan üniversite/bölüm tercihlerinden veya bu tercihlerin sonuçlarından hiçbir şekilde sorumlu tutulamaz. Tercih sürecinde yapılan hatalardan dolayı proje sahibine sorumluluk yüklenemez.

A Turkish version of this same warning is returned in every tool response's disclaimer field (see below) — the server instructions tell the calling model to always surface it to the user verbatim, not just leave it in this file.

Bu projeyi (bu MCP sunucusunu) indirerek, kurarak, çalıştırarak veya Claude Desktop, Codex, ChatGPT ya da başka bir istemci üzerinden bu sunucuya bağlanıp kullanarak, yukarıdaki sorumluluk reddi beyanının tamamını okuduğunuzu, anladığınızı ve kabul ettiğinizi beyan etmiş sayılırsınız.

Related MCP server: University Course Catalog MCP Server

MCP İstemcilerine Bağlanma (Claude Desktop, Codex, ChatGPT)

Herkese Açık Sunucu (kurulum gerektirmez)

Bu sunucu zaten https://yokatlas.aykutbuyukkaya.com/mcp adresinde yayında. Kendi bilgisayarınızda hiçbir şey kurmadan/çalıştırmadan, aşağıdaki "Custom Connector" adımlarında bu URL'yi kullanarak doğrudan bağlanabilirsiniz. Kendi kopyanızı çalıştırmak isterseniz aşağıdaki yerel kurulum adımlarını izleyebilirsiniz.

Sunucu varsayılan olarak stdio üzerinden çalışır; Claude Desktop, Claude Code ve Codex gibi istemciler sunucuyu doğrudan yerel bir alt süreç olarak başlattığı için ayrı bir HTTP kurulumu gerekmez. ChatGPT ise yalnızca internetten erişilebilen (HTTPS) bir MCP sunucusuna bağlanabildiği için ya yukarıdaki herkese açık adresi ya da kendi deploy ettiğiniz bir adresi kullanmanız gerekir.

Kendi kopyanızı çalıştırmak için önce bağımlılıkları kurun:

git clone <bu-repo-url>
cd yokatlas-mcp-server
uv sync

Claude Desktop

Claude Desktop'ın ayar dosyasını açın:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

mcpServers altına aşağıdaki girdiyi ekleyin (yolu kendi klonladığınız dizinle değiştirin) ve Claude Desktop'ı yeniden başlatın:

{
  "mcpServers": {
    "yokatlas-mcp-server": {
      "command": "uv",
      "args": ["--directory", "/path/to/yokatlas-mcp-server", "run", "yokatlas-mcp-server"]
    }
  }
}

Claude Code CLI kullanıyorsanız aynı işi tek satırla yapabilirsiniz:

claude mcp add yokatlas-mcp-server -- uv --directory /path/to/yokatlas-mcp-server run yokatlas-mcp-server

Custom Connector (uzak/HTTP sunucu) ile bağlanma: Kendi bilgisayarınızda hiçbir şey kurmadan, herkese açık sunucuyu kullanarak bağlanabilirsiniz:

  1. Claude Desktop'ta Settings → Connectors'a gidin.

  2. Add custom connector'a tıklayıp https://yokatlas.aykutbuyukkaya.com/mcp adresini MCP sunucu URL'si olarak girin ve ekleyin.

  3. Yeni bir sohbette bu connector'ı etkinleştirip araçları kullanmaya başlayın.

Kendi deploy ettiğiniz bir sunucuyu kullanmak isterseniz (bkz. Docker), 2. adımda kendi https://<alan-adiniz> adresinizi girmeniz yeterlidir.

Codex CLI (OpenAI)

~/.codex/config.toml dosyasına aşağıdaki bloğu ekleyin:

[mcp_servers.yokatlas-mcp-server]
command = "uv"
args = ["--directory", "/path/to/yokatlas-mcp-server", "run", "yokatlas-mcp-server"]

Codex CLI sürümünüz destekliyorsa aynı satırı komut satırından da ekleyebilirsiniz:

codex mcp add yokatlas-mcp-server -- uv --directory /path/to/yokatlas-mcp-server run yokatlas-mcp-server

ChatGPT (Connectors / Developer mode)

ChatGPT yerel bir komut çalıştıramadığı için sunucunun internetten erişilebilir bir HTTPS adresi olması gerekir. Herkese açık sunucuyu kullanabilir ya da kendi kopyanızı MCP_TRANSPORT=streamable-http ile (bkz. Docker) bir alan adının arkasına deploy edebilirsiniz, ardından:

  1. ChatGPT'de Settings → Connectors → Advanced → Developer mode'u açın (bu özellik hesap planınıza göre farklı bir menüde görünebilir).

  2. Add custom connector ile https://yokatlas.aykutbuyukkaya.com/mcp adresini (veya kendi deploy ettiğiniz https://<alan-adiniz> adresini) MCP sunucu URL'si olarak girin.

  3. Sohbette bu connector'ı etkinleştirip get_university_cities, get_universities, get_university_programs ve search_university_programs araçlarını kullanmaya başlayın.

command/args yolları uv'nin sistem PATH'inizde bulunduğunu varsayar; değilse command alanına uv'nin tam yolunu (örn. /opt/homebrew/bin/uv) yazmanız gerekir.

Diğer HTTP tabanlı istemciler için de MCP_TRANSPORT=streamable-http (veya sse) ayarlayıp http://<MCP_HOST>:<MCP_PORT> adresine bağlanmanız yeterlidir.

Tools

Tool

Upstream endpoint

Filters

get_university_cities

GET /api/tercih-kilavuz/universite-iller

name_contains, limit

get_universities

GET /api/tercih-kilavuz/universiteler

name_contains, limit

get_university_programs

GET /api/tercih-kilavuz/universite-programlar

name_contains, score_type, limit

search_university_programs

POST /api/tercih-kilavuz/search

see below

get_university_cities, get_universities, and get_university_programs are reference-data lookups. search_university_programs is the actual preference search — it returns program placements (university + program + quota + fee + scholarship + prior guide's minimum success rank / score cutoff), and its university_ids, program_group_ids, and city_codes filters are meant to be resolved first from the three lookup tools' id/ilKodu fields, not guessed.

search_university_programs also filters by program_type (46/"LİSANS", 47/"ÖNLİSANS"), university_type (DEVLET, VAKIF, "VAKIF MYO", KKTC, "YURTDIŞI KAMU", "YURTDIŞI VAKIF"), scholarship_type (0/"ÜCRETSİZ", 154/"ÜCRETLİ", 158/"BURSLU", 155/"%25 İNDİRİMLİ", 156/"%50 İNDİRİMLİ"), study_mode (86/"ÖRGÜN ÖĞRETİM", 182/"UZAKTAN ÖĞRETİM", 203/"AÇIK ÖĞRETİM"), an exact guide_code (to fetch one specific placement), a min_success_rank/max_success_rank range, and standard page/size (max 50)/sort_by/ direction pagination. All of the above accept either the raw id/code or the Turkish label — with or without diacritics, in any case ("lisans", "LİSANS", and 46 are equivalent). Set include_conditions_text=True to also get each result's full admission-condition paragraphs (conditions_text); left off by default since they can be long.

score_type accepts SAY, EA, SÖZ (or ASCII SOZ), DİL (or ASCII DIL), and TYT. Name filters are case-insensitive substring matches that handle Turkish dotted/dotless I correctly (e.g. name_contains="istanbul" matches İSTANBUL).

Every tool returns a standard envelope so callers can branch on success/failure without parsing exceptions. Every response also carries a disclaimer field with the Turkish warning above (experimental/AI-generated data, verify against the official YÖK ATLAS, get professional guidance):

{"ok": true, "data": {...}, "error": null, "disclaimer": "Bu sonuç deneysel..."}
{"ok": false, "data": null, "error": {"code": "INVALID_INPUT", "message": "...", "retryable": false}, "disclaimer": "Bu sonuç deneysel..."}

This full envelope (including disclaimer) is always available as structuredContent. But relying only on a JSON field inside structuredContent, plus the server's MCP instructions telling the model to relay it, turned out not to be reliable in practice — not every client forwards instructions to the model, and a field buried in a large JSON blob is easy for a model to summarize away. So each tool's actual text output (content) leads with the disclaimer as its own explicit, unmissable directive block, ahead of the JSON data — see envelope.to_call_tool_result().

Project layout

src/yokatlas_mcp_server/
  __init__.py
  settings.py                    # pydantic-settings config, loaded from env vars / .env
  errors.py                       # domain exceptions + {code, message, retryable} error payloads
  envelope.py                      # shared {ok, data, error, disclaimer} response helpers
  text_utils.py                     # Turkish-aware casefold/upper + int/limit validation
  enums.py                           # search filter value normalization (labels <-> ids)
  rate_limiter.py                     # async token-bucket limiter for the upstream client
  models.py                            # City, University, ProgramGroup dataclasses
  yokatlas_client.py                    # TercihKilavuzuClient: retries, rate limiting, error mapping
  server.py                              # FastMCP app: tool/resource/prompt registration, entry point
  tools/
    __init__.py
    get_university_cities.py
    get_universities.py
    get_university_programs.py
    search_university_programs.py

tests/
  test_scaffold.py                # settings + transport validation
  test_envelope.py                 # {ok, data, error, disclaimer} response helpers
  test_server_tool_dispatch.py     # real FastMCP tool-call dispatch, not execute_* directly
  test_enums.py                    # filter value normalization
  test_yokatlas_client.py          # HTTP client behavior against a mocked transport
  test_get_university_cities_tool.py
  test_get_universities_tool.py
  test_get_university_programs_tool.py
  test_search_university_programs_tool.py

Getting started

uv sync
cp .env.example .env
uv run pytest
uv run yokatlas-mcp-server

The default transport is stdio, so uv run yokatlas-mcp-server will sit waiting for an MCP client to speak to it over stdin/stdout — that's expected. Use mcp dev for an interactive inspector instead:

uv run mcp dev src/yokatlas_mcp_server/server.py

Adding a new tool

  1. Add a method to TercihKilavuzuClient in yokatlas_client.py, or create a new <domain>_client.py module following the same pattern (owns retries, rate limiting via RateLimiter, and translates HTTP/network failures into the errors.py exception hierarchy).

  2. Create tools/<name>.py with a Protocol describing the client methods the tool needs and an async def execute_<name>(...) that validates input, calls the client, and returns the envelope via envelope.make_success_response / make_error_response (copy tools/get_university_cities.py as a starting point).

  3. Register it in server.py with @mcp.tool(name=..., description=...), describing each parameter with a pydantic Field(description=...) so MCP clients get useful tool docs.

  4. Add tests mirroring test_get_university_cities_tool.py (fake client, no network) and, if you added a client method, test_yokatlas_client.py (real client, httpx.MockTransport, no network).

Docker

uv lock
docker build -t yokatlas-mcp-server .
docker run --rm -p 8000:8000 yokatlas-mcp-server

The image defaults MCP_TRANSPORT to streamable-http and binds to 0.0.0.0:8000. uv lock must be run once (and whenever dependencies change) to produce uv.lock, which the Dockerfile installs from with --frozen for reproducible builds.

Configuration

See .env.example for all supported environment variables: MCP transport/host/port, logging, and the YÖK ATLAS API's base URL, timeouts, retry policy, and rate limit.

License

MIT — see LICENSE.

Available Tools

4 tools
get_universitiesA

List universities in the YOK ATLAS preference guide. Optionally filter by a case-insensitive substring of the university name and/or cap the number of results. Returns a standard envelope: {ok, data, error, disclaimer}.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoOptional maximum number of results to return. Must be > 0 when set.
name_containsNoOptional case-insensitive substring to filter university names by.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden for behavioral disclosure. It does disclose the return envelope and the case-insensitive filter behavior, which is good. However, it does not mention potential default limits, pagination, or any error conditions beyond the envelope. For a simple read tool, this is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the primary purpose, and includes concise optional details. Every word serves a purpose, with no redundancy or irrelevant content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with only two optional parameters and an output schema present. The description covers the scope (listing universities), the filtering options, and the response envelope. Since the output schema exists, the description need not detail return fields. It is complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already provides 100% coverage for both parameters (limit and name_contains) with clear descriptions. The tool description merely restates these options without adding new semantic information, so it meets the baseline but adds no extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'List universities in the YOK ATLAS preference guide' with a specific verb and resource. It distinguishes from sibling tools like get_university_cities and get_university_programs by focusing on universities themselves, and from search_university_programs by being a list rather than a search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: it lists universities with optional filters, making it clear this is for retrieving university lists. It doesn't explicitly name alternatives, but the sibling tool names and the phrase 'in the YOK ATLAS preference guide' provide clear context. No exclusions are mentioned, but the specification is enough for an agent to infer when to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_university_citiesA

List provinces (il) used by YOK ATLAS to filter university preference searches. Optionally filter by a case-insensitive substring of the province name and/or cap the number of results. Returns a standard envelope: {ok, data, error, disclaimer}.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoOptional maximum number of results to return. Must be > 0 when set.
name_containsNoOptional case-insensitive substring to filter province names by.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses the filtering behavior (case-insensitive substring), the optional limit, and the return envelope format ({ok, data, error, disclaimer}). It does not mention ordering, pagination, or potential edge cases, but for a simple read-only list tool, the disclosed behavior is substantial.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the main purpose, and every phrase contributes value. It is concise with no redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple (2 optional parameters, no required params, output schema present). The description covers the purpose, the use case, parameter options, and the response envelope. With an output schema available, not detailing every return field is acceptable. The description is complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description restates the parameter behavior ('case-insensitive substring' and 'cap the number of results') but does not add meaningful detail beyond the schema's own descriptions. It adds no new semantic information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'List' with a clear resource: 'provinces (il) used by YOK ATLAS to filter university preference searches.' This clearly distinguishes it from sibling tools that deal with universities or programs, as it focuses on provinces only.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context: the tool is for listing provinces used in YOK ATLAS university preference searches. It implies when to use it (when needing province options for filtering) without explicitly naming alternatives, but the sibling tool names make the differentiation obvious. No exclusions or alternative guidance are given, but the use case is evident.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_university_programsA

List YOK ATLAS program groups (birim grup), e.g. 'Bilgisayar Muhendisligi', each tagged with its exam score type (SAY, EA, SOZ/SÖZ, DIL/DİL, or TYT). Optionally filter by a case-insensitive substring of the program name, a score type (ASCII spellings like SOZ/DIL are accepted), and/or cap the number of results. Returns a standard envelope: {ok, data, error, disclaimer}.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoOptional maximum number of results to return. Must be > 0 when set.
score_typeNoOptional score type filter: SAY, EA, SOZ (SÖZ), DIL (DİL), or TYT. ASCII spellings without diacritics are accepted.
name_containsNoOptional case-insensitive substring to filter program names by.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses the return envelope ({ok, data, error, disclaimer}), filter behavior (case-insensitive substring, ASCII score type spellings), and the optional limit. The 'List' verb implies a read-only operation. It does not discuss error conditions or rate limits, but for a listing tool this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loads the main purpose, and includes only essential details (examples, filters, envelope). Zero wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has three optional parameters, an output schema, and sibling tools. The description covers the core behavior, filter semantics, and return envelope. It is complete for a read-only listing tool, but could be enhanced by mentioning how it relates to 'search_university_programs'.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds minor clarifications like 'case-insensitive substring' and 'cap the number of results', but these largely repeat what the schema says. Baseline 3 is appropriate where the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists YOK ATLAS program groups with a concrete example ('Bilgisayar Muhendisligi'). It does not explicitly differentiate from the sibling 'search_university_programs', but the verb 'List' plus resource makes the primary purpose clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through its clear listing and filter capabilities, but provides no explicit guidance on when to use this tool versus the sibling 'search_university_programs' or other alternatives. There are no exclusions or 'when not to use' statements.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_university_programsA

Search YOK ATLAS program placements -- the core preference-search endpoint. university_ids, program_group_ids, and city_codes must be resolved first via get_universities, get_university_programs, and get_university_cities respectively (this tool does not do its own name lookups). Returns each matching placement's university, program, quota, fee, scholarship, and the prior guide's minimum success rank / score cutoff, paginated. Returns a standard envelope: {ok, data, error, disclaimer}.

ParametersJSON Schema
NameRequiredDescriptionDefault
pageNoZero-based page index.
sizeNoResults per page. Must be between 1 and 50.
sort_byNoField to sort by: basariSirasi, minPuan, kontenjan, universiteAdi, birimAdi, or ilAdi.basariSirasi
directionNoSort direction: ASC or DESC.ASC
city_codesNoOptional province codes from get_university_cities to filter by.
guide_codeNoOptional exact guide code (kilavuzKodu) of one specific placement, as seen in a prior search_university_programs result, to fetch just that row.
score_typeNoOptional score type filter: SAY, EA, SOZ (SÖZ), DIL (DİL), or TYT.
study_modeNoOptional study mode: 86 or 'ORGUN OGRETIM', 182 or 'UZAKTAN OGRETIM', 203 or 'ACIK OGRETIM'.
program_typeNoOptional program level: 46 or 'LISANS', 47 or 'ONLISANS'.
university_idsNoOptional university ids from get_universities to filter by.
university_typeNoOptional university type: DEVLET, VAKIF, 'VAKIF MYO', KKTC, 'YURTDISI KAMU', or 'YURTDISI VAKIF'.
max_success_rankNoOptional maximum prior-year success rank (basari sirasi), inclusive.
min_success_rankNoOptional minimum prior-year success rank (basari sirasi), inclusive.
scholarship_typeNoOptional scholarship/fee tier: 0 or 'UCRETSIZ', 154 or 'UCRETLI', 158 or 'BURSLU', 155 or '%25 INDIRIMLI', 156 or '%50 INDIRIMLI'.
program_group_idsNoOptional program group ids from get_university_programs to filter by.
include_conditions_textNoIf true, include the full admission-condition paragraphs for each result (conditions_text). These can be long; leave false unless the caller specifically needs the condition wording.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.7/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses the return fields (university, program, quota, fee, scholarship, cutoff), pagination, and the standard envelope {ok, data, error, disclaimer}. It does not mention auth or rate limits, but as a read-oriented search tool the disclosed behavior is reasonably complete and non-contradictory.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, front-loaded with the primary purpose, then prerequisites, then return behavior. Every sentence adds essential information with no filler or repetition of schema details that aren't relevant to decision-making.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (16 optional parameters, output schema present), the description covers the essential context: what the tool is, how it relates to siblings, what prerequisites exist, what it returns, and the response envelope. The detailed schema handles parameter specifics, so the description is appropriately complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with each parameter already described in detail, so the baseline is 3. The description adds extra semantic value by explicitly stating that university_ids, program_group_ids, and city_codes must be resolved via sibling tools and that the tool does no name lookups—clarifying why these parameters are needed and how they relate to the rest of the system.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description identifies the tool as the core preference-search endpoint for YOK ATLAS program placements, using a specific verb ('Search') and resource ('program placements'). It clearly distinguishes from sibling lookup tools by stating that ID resolution must happen via get_universities, get_university_programs, and get_university_cities first.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly tells the agent which prerequisites must be met before calling (university_ids, program_group_ids, city_codes resolved via three named sibling tools) and notes that this tool does not do name lookups. This gives concrete when-to-use guidance and steers the agent toward alternatives when name-based search is needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

A4.3/5.0
Disambiguation5/5

Each tool targets a distinct resource: cities, universities, program groups, and placement search. The search tool explicitly relies on IDs resolved from the other three, making boundaries clear and preventing misselection.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case: get_* for reference lookups and search_* for the complex query. The pattern is predictable and uniform.

Tool Count5/5

Four tools cover the core domain without bloat or thinness. Each tool has a distinct role, and the count fits the purpose of a reference/search server well within the ideal 3-15 range.

Completeness5/5

The surface covers the full workflow: resolving reference data (cities, universities, programs) and performing the main placement search. No obvious gaps or dead ends exist for the stated purpose.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AykutBuyukkaya/yokatlas-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server