VS Code прокачали и завезли Agent Skills - открытый стандарт от Anthropic для расширения AI-агентов специализированными возможностями.

Работает с Claude Code и скоро будет поддержка Cursor.

👉 @PythonPortal

Эта новая графовая БД в 496 раз быстрее Neo4j!

Давайте разберем почему:

Классическая графовая БД хранит две вещи: узлы (entities) и ребра (relationships между ними).

Когда вы делаете запрос в классическую графовую БД, она делает обход через pointer chasing:

→ стартуем с узла
→ переходим по указателю к связанному узлу
→ еще один указатель
→ и так далее

Это по своей природе последовательный процесс. Один hop за раз. И по мере роста графа это становится болезненно медленным.

FalkorDB задает другой вопрос:

А что если представить весь граф как матрицу?

Как это работает:

Представьте обычную таблицу. Строки — source nodes, колонки — destination nodes.

Если Mary подписана на Bob, ставим в позицию [Mary, Bob] = 1.

Все. Весь граф теперь это матрица из 1 и 0.

Назовем ее матрицей Follows (F).

Дальше интереснее:

Хотите узнать на кого подписаны друзья Mary? В классической графовой БД вам нужно сделать два перехода: Mary → друзья → друзья друзей.

Но с матрицами вы просто умножаете матрицу Follows саму на себя: F × F = F².

Это одна операция — и готово!

А более сложный паттерн вида “A follows B, B likes C” превращается в: Follows × Likes.

То есть traversal можно выразить через математику.

Почему это важно:

- матричные операции оптимизируются уже больше 50 лет
- современное железо (CPU/GPU) заточено под матрицы
- операции выполняются параллельно (pointer chasing не может)

Плюс есть еще несколько оптимизаций (например sparse matrices, реализация на C и т.д.), и все это делает FalkorDB в 496 раз быстрее Neo4j.

График на фото это хорошо показывает.

Классические графовые БД идут через Cypher QL → Pointer-Based Traversal, а FalkorDB использует Matrix-Aware Planner, который превращает запросы в матричные операции.

FalkorDB полностью строится на этом принципе:

- нативный модуль Redis (in-memory и очень быстрый)
- использует GraphBLAS для sparse matrix вычислений
- автоматически транслирует Cypher-запросы в матрическую алгебру

Это важная тема для AI-приложений, потому что…

Современным AI-агентам и RAG-системам нужно обходить сложные связи в реальном времени. Когда агент делает reasoning через knowledge graph, связывая пользователей, действия и результаты — каждая миллисекунда задержки складывается.

Vector DBs ловят семантическую близость. Но они не держат явных связей.

Knowledge graphs закрывают эту дыру.

И когда вашему агенту нужно делать multi-hop reasoning по тысячам связанных сущностей, матричный traversal упрощает масштабирование AI-приложения без проблем с задержками.

FalkorDB полностью open-source, вы можете посмотреть реализацию на GitHub и попробовать сами.

Ссылка на GitHub-репозиторий

👉 @PythonPortal

Tailwind уволила 75% своего персонала, потому что почти никто их не поддерживает.

В отчаянной попытке избежать банкротства они выпустили свой фильм в кинотеатрах.

Честно говоря, вы бы заплатили, чтобы посмотреть его? 😆

👉 @PythonPortal

А что если обучать AI-агентов на обычном ноуте было бы так же просто, как на GPU-кластере?

Команда из UIUC U Lab под руководством проф. Jiaxuan You выложила в опенсорс OpenTinker.

Это новая система формата Reinforcement-Learning-as-a-Service (RLaaS), которая разбивает тяжелый RL-пайтлайн на простые распределенные сервисы с удобными API.

Итог — снимает большую часть инженерных болячек вокруг RL, обгоняя классические фреймворки по доступности и простоте деплоя, наконец-то делая обучение агентов реалистичным вариантом для обычных разработчиков и команд.

Project: https://open-tinker.github.io/opentinker-page/
Code: https://github.com/open-tinker/OpenTinker
U Lab: https://github.com/ulab-uiuc

👉 @PythonPortal

Научная фантастика, на которой мы выросли, становится реальностью в 2026 году 👀

👉 @PythonPortal

😆😆😆

👉 @PythonPortal

4 парадигмы обучения в машинном обучении, объяснённые визуально:

1. Transfer Learning
2. Fine-tuning
3. Multi-task Learning
4. Federated Learning

👉 @PythonPortal

кресло для программирования против кресла для отладки.

👉 @PythonPortal

Сейчас ИИ-инструменты уже умеют читать сообщения, размышлять над ними и сами дергать нужные функции.

Для сборки таких связок есть LangChain — популярный фреймворк, который позволяет подружить языковые модели, инструменты и приложения.

В этом туториале показывают, как собрать и задеплоить своего ИИ-агента на связке LangChain, FastAPI и Sevalla.

👉 @PythonPortal

Совет по Python:

Можно сделать поля dataclass неизменяемыми, указав frozen=True.
В таком случае поля нельзя мутировать после создания инстанса.

Пример ниже👇

from dataclasses import dataclass

@dataclass(frozen=True)
class Color:
    name: str
    hex_value: str

color = Color("red", "#FF0000")

# color.name = "blue"  # выбросит FrozenInstanceError

👉 @PythonPortal

Каждый раз, когда я узнаю что-то новое в области технологий, в отрасли появляется еще три новых вещи, которые нужно изучить.

👉 @PythonPortal

Лучшие библиотеки Python 2026 года

Общего назначения

▪️ty — сверхбыстрый type checker нового поколения
▪️complexipy — измеряет сложность кода так, как её чувствует человек
▪️Kreuzberg — извлечение данных из 50+ форматов
▪️hrottled-py — rate limiting с 5 алгоритмами
▪️httptap — HTTP waterfall прямо в терминале
▪️ fastapi-guard — безопасность FastAPI без боли
▪️modshim — расширяй модули без monkey-patching
▪️Spec Kit — спецификации → рабочий код
▪️Skylos — dead code + уязвимости
▪️FastOpenAPI — OpenAPI для любого фреймворка

AI / ML / Data

▪️MCP Python SDK + FastMCP — стандарт интеграции LLM с инструментами
▪️TOON — JSON, оптимизированный под токены
▪️ Deep Agents — агенты с планированием и памятью
▪️ smolagents — агенты, которые думают кодом
▪️ LlamaIndex Workflows — event-driven AI workflows
▪️ Batchata — дешёвые batch-запросы к LLM
▪️ MarkItDown — любые файлы → Markdown
▪️ Data Formulator — анализ данных через natural language
▪️ LangExtract — точное извлечение сущностей из текста
▪️ GeoAI — ML + геоданные без боли

Детально, с примерами и разбором — в полной статье

👉 @PythonPortal

Ускорение процесса решето Эратосфена

1. Быстро вспомним алгоритм

Классическая реализация:

def eratosthenes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False

    for i in range(2, int(n ** 0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, n + 1, i):
                is_prime[j] = False

    return is_prime

Время — O(N log log N). Нас будет интересовать не асимптотика, а то, насколько можно ускорить чисто реализацией.

2. Оптимизация №1 — не трогаем чётные числа

Идея простая:

* все чётные, кроме 2, составные
* если работаем только с нечётными, уменьшаем массив и количество итераций примерно вдвое

Реализация:

def eratosthenes_odd(n):
    if n < 2:
        return []

    size = (n + 1) // 2
    is_prime = [True] * size
    is_prime[0] = False

    limit = int(n ** 0.5) // 2
    for i in range(1, limit + 1):
        if is_prime[i]:
            p = 2 * i + 1
            start = (p * p) // 2
            for j in range(start, size, p):
                is_prime[j] = False

    return is_prime

3. Оптимизация №2 — вместо list[bool] использовать bytearray

Мысль:

* bool в Python — это объект
* bytearray — плотно упакованный буфер
* меньше накладных расходов и лучше ложится в CPU cache

Пример:

def eratosthenes_bytearray(n):
    is_prime = bytearray(b"\x01") * (n + 1)
    is_prime[0:2] = b"\x00\x00"

    for i in range(2, int(n ** 0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, n + 1, i):
                is_prime[j] = 0

    return is_prime

4. Оптимизация №3 — гибрид двух подходов

def eratosthenes_fast(n):
    if n < 2:
        return []

    size = (n + 1) // 2
    is_prime = bytearray(b"\x01") * size
    is_prime[0] = 0

    limit = int(n ** 0.5) // 2
    for i in range(1, limit + 1):
        if is_prime[i]:
            p = 2 * i + 1
            start = (p * p) // 2
            is_prime[start::p] = b"\x00" * (((size - start - 1) // p) + 1)

    return is_prime

5. Сравнение по времени

Тест на входе n = 10_000_000:

>>> eratosthenes.py
real  0.634s

>>> eratosthenes_odd.py
real  0.245s

>>> eratosthenes_bytearray.py
real  0.801s

>>> eratosthenes_fast.py
real  0.028s

Выводы:

* пропуск чётных (№1) даёт ~2.6× ускорение
* bytearray (№2) сам по себе не ускоряет — это больше про память
* гибрид (№3) даёт ~22.6× ускорение

Ключевой приём в №3:

is_prime[start::p] = b"\x00" * (((size - start - 1) // p) + 1)

Здесь нет Python-цикла — всё делает C-уровневая операция над слайсом. На таких задачах это огромная разница.

Общая мысль: в Python чаще всего ускоряют не асимптотику, а модель памяти и количество проходов по данным. Циклы + память → главные факторы.

👉 @PythonPortal