YÖK Atlas MCP Server
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@YÖK Atlas MCP ServerSearch for computer engineering programs in Istanbul."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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 syncClaude Desktop
Claude Desktop'ın ayar dosyasını açın:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%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-serverCustom Connector (uzak/HTTP sunucu) ile bağlanma: Kendi bilgisayarınızda hiçbir şey kurmadan, herkese açık sunucuyu kullanarak bağlanabilirsiniz:
Claude Desktop'ta Settings → Connectors'a gidin.
Add custom connector'a tıklayıp
https://yokatlas.aykutbuyukkaya.com/mcpadresini MCP sunucu URL'si olarak girin ve ekleyin.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-serverChatGPT (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:
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).
Add custom connector ile
https://yokatlas.aykutbuyukkaya.com/mcpadresini (veya kendi deploy ettiğinizhttps://<alan-adiniz>adresini) MCP sunucu URL'si olarak girin.Sohbette bu connector'ı etkinleştirip
get_university_cities,get_universities,get_university_programsvesearch_university_programsaraçlarını kullanmaya başlayın.
command/argsyollarıuv'nin sistem PATH'inizde bulunduğunu varsayar; değilsecommandalanınauv'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 |
|
|
|
|
|
|
|
|
|
|
| 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.pyGetting started
uv sync
cp .env.example .env
uv run pytest
uv run yokatlas-mcp-serverThe 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.pyAdding a new tool
Add a method to
TercihKilavuzuClientinyokatlas_client.py, or create a new<domain>_client.pymodule following the same pattern (owns retries, rate limiting viaRateLimiter, and translates HTTP/network failures into theerrors.pyexception hierarchy).Create
tools/<name>.pywith aProtocoldescribing the client methods the tool needs and anasync def execute_<name>(...)that validates input, calls the client, and returns the envelope viaenvelope.make_success_response/make_error_response(copytools/get_university_cities.pyas a starting point).Register it in
server.pywith@mcp.tool(name=..., description=...), describing each parameter with a pydanticField(description=...)so MCP clients get useful tool docs.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-serverThe 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 toolsget_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}.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Optional maximum number of results to return. Must be > 0 when set. | |
| name_contains | No | Optional case-insensitive substring to filter university names by. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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}.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Optional maximum number of results to return. Must be > 0 when set. | |
| name_contains | No | Optional case-insensitive substring to filter province names by. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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}.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Optional maximum number of results to return. Must be > 0 when set. | |
| score_type | No | Optional score type filter: SAY, EA, SOZ (SÖZ), DIL (DİL), or TYT. ASCII spellings without diacritics are accepted. | |
| name_contains | No | Optional case-insensitive substring to filter program names by. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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}.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Zero-based page index. | |
| size | No | Results per page. Must be between 1 and 50. | |
| sort_by | No | Field to sort by: basariSirasi, minPuan, kontenjan, universiteAdi, birimAdi, or ilAdi. | basariSirasi |
| direction | No | Sort direction: ASC or DESC. | ASC |
| city_codes | No | Optional province codes from get_university_cities to filter by. | |
| guide_code | No | Optional exact guide code (kilavuzKodu) of one specific placement, as seen in a prior search_university_programs result, to fetch just that row. | |
| score_type | No | Optional score type filter: SAY, EA, SOZ (SÖZ), DIL (DİL), or TYT. | |
| study_mode | No | Optional study mode: 86 or 'ORGUN OGRETIM', 182 or 'UZAKTAN OGRETIM', 203 or 'ACIK OGRETIM'. | |
| program_type | No | Optional program level: 46 or 'LISANS', 47 or 'ONLISANS'. | |
| university_ids | No | Optional university ids from get_universities to filter by. | |
| university_type | No | Optional university type: DEVLET, VAKIF, 'VAKIF MYO', KKTC, 'YURTDISI KAMU', or 'YURTDISI VAKIF'. | |
| max_success_rank | No | Optional maximum prior-year success rank (basari sirasi), inclusive. | |
| min_success_rank | No | Optional minimum prior-year success rank (basari sirasi), inclusive. | |
| scholarship_type | No | Optional scholarship/fee tier: 0 or 'UCRETSIZ', 154 or 'UCRETLI', 158 or 'BURSLU', 155 or '%25 INDIRIMLI', 156 or '%50 INDIRIMLI'. | |
| program_group_ids | No | Optional program group ids from get_university_programs to filter by. | |
| include_conditions_text | No | If 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
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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
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.
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.
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.
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
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
Trust verification for MCP servers. Check scores, scan for security issues, search 4,200+ servers.
This MCP server provides seamless access to Malaysia's government open data, including datasets, w…
Official MCP server for Certifier to issue, manage, and track certificates and badges.
Public MCP server for discovering open jobs. Search, filter, and get application links.
Related MCP Servers
- AlicenseAqualityCmaintenanceProvides an MCP interface for accessing YOKATLAS (Turkish Higher Education Council Atlas) data, enabling LLM applications like Claude to search and retrieve details about undergraduate and associate degree programs in Turkey.471MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for querying a university course catalog. Enables searching courses, checking prerequisites, and looking up instructors via natural language.
- AlicenseAqualityDmaintenanceMCP server for live Turkey data — gold & silver prices, official TCMB exchange rates, fuel pump prices, prayer times and the Kandilli earthquake feed.759MIT
- FlicenseAqualityDmaintenanceMCP server for querying TÜBİTAK TR Dizin academic database, enabling search of publications, journals, authors, and institutions without an API key.9
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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