🚀 Исправляем распространенную ошибку в проверке простых чисел

Недавно я написал код для проверки, является ли число простым, но в нем была неявная ошибка, которую часто допускают даже опытные разработчики. 😈

---

🛑 Ошибка:
В этой строке:

for i in range(2, int(n ** 0.5)):  

Мы не включаем верхнюю границу диапазона range(), но она должна быть int(n 0.5) + 1**!

Из-за этого алгоритм не проверял делимость на корень числа, а значит, некоторые составные числа ошибочно считались простыми. Например, 25 считалось простым, потому что 5 не проверялся.

---

### ✅ Исправленный код:

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):  # ✅ Теперь проверяем и сам корень!
        if n % i == 0:
            return False
    return True

# 🔍 Тестируем
test_numbers = [1, 2, 3, 4, 5, 16, 17, 19, 20, 23, 25]
for num in test_numbers:
    print(f"{num}: {'Простое' if is_prime(num) else 'Составное'}")

---

💡 Итог:
✅ Теперь код корректно определяет все числа!
✅ Ошибка была связана с неправильным диапазоном в `range()`.
✅ Если ты проверяешь делители до √n, не забудь включить +1 в range().

💬 Кто сталкивался с такой ошибкой? Поделитесь в комментариях! 🚀

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

На Habr вышла вторая часть статьи "Как я сделал RAG для своей компании (часть 2). И как начал делать AI Агента." 🧐

Backlog проекта RAG + Agent AI для своей компании растет на глазах. Чем больше делаешь, тем больше идей💡В следующей части планирую выложить miro архитектуру проекта + github. Следите, подписывайтесь на habr. На картинке драфт архитектуры.

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

QR-коды могут содержать разнообразные данные, а не только ссылки! 📲✨

🔹 Что можно зашифровать в QR-код?

✅ Текст – любой текст или сообщение.
✅ Контактные данные (vCard) – имя, телефон, email, адрес.
✅ Wi-Fi данные – SSID и пароль для быстрого подключения.
✅ Электронная почта (mailto) – открывает окно для написания письма.
✅ SMS-сообщение (sms:) – подставляет номер и текст.
✅ Геолокация – координаты (широта и долгота).
✅ Криптокошельки – Bitcoin, Ethereum и другие.
✅ Команды для приложений – WhatsApp, Telegram, PayPal и др.

---

📌 Примеры кодов и их данных

1️⃣ Текстовый QR-код

qr.add_data("Привет! Это текст внутри QR-кода! 😊")

2️⃣ QR-код с контактами (vCard)

vcard = """BEGIN:VCARD
VERSION:3.0
FN:Иван Иванов
TEL:+79161234567
EMAIL:ivan@example.com
END:VCARD"""
qr.add_data(vcard)

3️⃣ QR-код для подключения к Wi-Fi

wifi_data = "WIFI:S:MyNetwork;T:WPA;P:MyPassword;;"
qr.add_data(wifi_data)

📶 После сканирования телефон автоматически подключится к Wi-Fi!

4️⃣ QR-код с координатами (например, Красная площадь, Москва)

geo_data = "geo:55.7539,37.6208"
qr.add_data(geo_data)

5️⃣ QR-код для мгновенного перевода криптовалюты (например, Bitcoin)

btc_address = "bitcoin:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa?amount=0.01"
qr.add_data(btc_address)

---

🛠 Полный код для генерации QR-кодов с разными данными

import qrcode  

# Замените данные на нужные вам
data = "WIFI:S:MyNetwork;T:WPA;P:MyPassword;;"  # Данные для Wi-Fi

# Генерация QR-кода
qr = qrcode.make(data)

# Сохранение изображения
qr.save("qr_code.png")
print("✅ QR-код сохранен как 'qr_code.png'")

---

💡 Как можно применять?
✔ Визитки – добавляйте QR-код с контактами 📇
✔ Wi-Fi в кафе – клиенты подключаются без пароля 📶
✔ Маркетинг – ссылки на соцсети, акции, сайты 🏪
✔ Криптоплатежи – удобный перевод крипты 🚀
✔ Билеты и доступ – QR-коды для мероприятий 🎟

QR-коды многофункциональны, и их можно использовать не только для ссылок! 🔥

Ты уже пробовал создавать свои QR-коды? 😎

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

🛡 Как работают SQL-инъекции на Python?

SQL-инъекция — это одна из самых опасных уязвимостей, которая позволяет взломать базу данных через неправильно обработанные запросы. Давайте разберем это на примере Python + SQLite.


🚨 Уязвимый код (НЕЛЬЗЯ ТАК ПИСАТЬ!)

import sqlite3

# Создаем тестовую базу данных
conn = sqlite3.connect(":memory:")  # Используем оперативную память (не сохраняется на диск)
cursor = conn.cursor()

# Создаем таблицу пользователей
cursor.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT, password TEXT)")
cursor.execute("INSERT INTO users (username, password) VALUES ('admin', 'supersecret')")
conn.commit()

# 🚨 Вход пользователя (уязвимый код!)
username = input("Введите имя пользователя: ")
password = input("Введите пароль: ")

query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{password}'"
print(f"\n[DEBUG] SQL-запрос: {query}")  # Показываем SQL-запрос (чтобы увидеть проблему)

cursor.execute(query)
user = cursor.fetchone()

if user:
    print("✅ Доступ разрешен!")
else:
    print("❌ Неверный логин или пароль!")

conn.close()

🕵 Как это взломать?
Допустим, злоумышленник вводит в поле "Имя пользователя":

' OR '1'='1

Тогда SQL-запрос превратится в:

SELECT * FROM users WHERE username = '' OR '1'='1' AND password = ''

А так как '1'='1' всегда истина, то запрос вернет всех пользователей, и злоумышленник войдет в систему без пароля! 😨


✅ Как защититься? Используем параметризованные запросы!
Исправим уязвимость с помощью защищенных SQL-запросов:

# 🔒 Безопасная версия
query = "SELECT * FROM users WHERE username = ? AND password = ?"
cursor.execute(query, (username, password))
user = cursor.fetchone()

Теперь любые вредоносные символы (`'`, --, OR, `1=1`) не повлияют на SQL-запрос, так как Python передает их как безопасные параметры, а не код.


💡 Итог
✅ SQL-инъекции = опасно!
✅ Никогда не вставляйте данные напрямую в SQL-запросы!
✅ Используйте `cursor.execute("... WHERE username = ?", (username,))`

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

🛡 Code Injection на Python: как это работает и как защититься

Code Injection (внедрение кода) — это атака, при которой злоумышленник заставляет приложение выполнить произвольный код.
На Python такое может случиться, если использовать `eval()` или `exec()` с неподконтрольными данными.


🚨 Уязвимый код (НЕЛЬЗЯ ТАК ПИСАТЬ!)

user_input = input("Введите математическое выражение: ")
result = eval(user_input)  # ОПАСНО! Позволяет выполнить любой код
print(f"Результат: {result}")

🕵 Как это взломать?
Допустим, злоумышленник вводит:

__import__('os').system('rm -rf /')  # Удалит все файлы на Linux!

или

__import__('subprocess').getoutput('ls')  # Выполнит команду терминала

Так как eval() выполняет ПОЛНОЦЕННЫЙ Python-код, атакующий может удалять файлы, читать данные и делать все, что угодно! 😱


✅ Как защититься?
1️⃣ Не используйте `eval()` и `exec()` с пользовательскими данными!
2️⃣ Если вам нужно безопасно вычислять выражения, используйте ast.literal_eval():

import ast

user_input = input("Введите число или выражение (2+2): ")

try:
    result = ast.literal_eval(user_input)  # Безопасно вычисляет только числа, списки, кортежи
    print(f"Результат: {result}")
except (ValueError, SyntaxError):
    print("Ошибка: недопустимый ввод!")

🔒 Теперь злоумышленник не сможет выполнить команды системы, так как literal_eval() позволяет только простые структуры (`int`, float, list, `tuple`).


🔥 Итог
❌ eval(user_input) = ДЫРКА В БЕЗОПАСНОСТИ!
✅ ast.literal_eval(user_input) = безопасный вариант
📌 Всегда фильтруйте ввод от пользователя!


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

🍀 Код в честь Дня Святого Патрика! Сколько пива выпьют в Ирландии? 🍻

День Святого Патрика (17 марта) — самый пивной праздник в Ирландии! Давайте посчитаем, сколько пинт пива выпьют в 2025 году.

📌 Факты для расчетов:
📊 В 2019 году в Ирландии выпили ~13 миллионов пинт в этот день.
📈 Средний рост потребления пива на праздник — 2% в год.
👥 Население Ирландии — ~5,3 млн человек (2025).

🍺 Код на Python

# Исходные данные
base_pints_2019 = 13_000_000  # Пинт выпито в 2019 году
growth_rate = 0.02  # Средний рост потребления (2% в год)
years = 2025 - 2019  # Сколько лет прошло

# Считаем пиво в 2025 году
pints_2025 = base_pints_2019 * ((1 + growth_rate) ** years)

# Выводим результат
print(f"🍀 В День Святого Патрика 2025 года в Ирландии выпьют примерно {int(pints_2025):,} пинт пива! 🍻")

📊 Результат:
Около 14,6 миллионов пинт! 😲 🍺

💡 Что можно добавить?
✅ Учет роста населения 📈
✅ Разделить на Guinness vs. другое пиво 🍺
✅ Сравнить с водопотреблением в стране 🚰

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

Давайте создадим пример простого AI-агента, который использует OpenAI Function Calling для выполнения задач на основе пользовательских запросов. Мы будем использовать случай, где агент помогает пользователю отслеживать свои задачи. Он будет принимать запросы от пользователя, добавлять задачи в список и позволять пользователю получать их.

Для этого мы будем использовать OpenAI GPT-4 с Function Calling.

Шаги:

1. Создаём функцию для добавления задач.
2. Создаём функцию для получения всех задач.
3. Создаём функцию для удаления задачи.

import openai
import json

# Устанавливаем ваш API ключ OpenAI
openai.api_key = 'your-openai-api-key'

# Переменная для хранения задач
tasks = []

# Функция для добавления задачи
def add_task(task):
    tasks.append(task)
    return f"Задача '{task}' добавлена."

# Функция для получения списка задач
def get_tasks():
    if tasks:
        return "Список задач:\n" + "\n".join([f"{i+1}. {task}" for i, task in enumerate(tasks)])
    else:
        return "Список задач пуст."

# Функция для удаления задачи
def delete_task(task_index):
    try:
        removed_task = tasks.pop(task_index - 1)
        return f"Задача '{removed_task}' удалена."
    except IndexError:
        return "Ошибка: Неверный индекс задачи."

# Функции OpenAI для обработки команд
def function_call_handler(function_name, args):
    if function_name == "add_task":
        return add_task(args["task"])
    elif function_name == "get_tasks":
        return get_tasks()
    elif function_name == "delete_task":
        return delete_task(args["task_index"])
    else:
        return "Неизвестная функция."

# Настроим prompt с описанием задач для OpenAI
functions = [
    {
        "name": "add_task",
        "description": "Добавить задачу в список.",
        "parameters": {
            "type": "object",
            "properties": {
                "task": {
                    "type": "string",
                    "description": "Описание задачи"
                }
            },
            "required": ["task"]
        }
    },
    {
        "name": "get_tasks",
        "description": "Получить список всех задач.",
        "parameters": {
            "type": "object",
            "properties": {}
        }
    },
    {
        "name": "delete_task",
        "description": "Удалить задачу по индексу.",
        "parameters": {
            "type": "object",
            "properties": {
                "task_index": {
                    "type": "integer",
                    "description": "Индекс задачи, которую нужно удалить."
                }
            },
            "required": ["task_index"]
        }
    }
]

# Функция для общения с OpenAI
def chat_with_agent(user_input):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "system",
            "content": "Ты помощник для отслеживания задач. Ты можешь добавлять, показывать и удалять задачи."
        }, {
            "role": "user",
            "content": user_input
        }],
        functions=functions,
        function_call="auto"
    )

    # Получаем ответ и выполняем функцию
    message = response['choices'][0]['message']
    if "function_call" in message:
        function_name = message["function_call"]["name"]
        arguments = json.loads(message["function_call"]["arguments"])
        return function_call_handler(function_name, arguments)
    
    return message['content']

# Пример взаимодействия с агентом
while True:
    user_input = input("Введите команду: ")
    if user_input.lower() in ["exit", "quit"]:
        print("До свидания!")
        break
    response = chat_with_agent(user_input)
    print("Ответ агента:", response)

ChatGPT с функциями:
- Используется API openai.ChatCompletion.create() для вызова модели GPT-4.
- Функции, которые агент может вызывать, передаются в параметре functions.
- В зависимости от того, что хочет сделать пользователь (например, добавить задачу или удалить), OpenAI вызывает соответствующую функцию.

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

Пример работы, кода выше 👆👆👆

Пользователь:

Введите команду: Добавить задачу купить молоко

Агент:

Ответ агента: Задача 'купить молоко' добавлена.

Пользователь:

Введите команду: Показать задачи

Агент:

Ответ агента: Список задач:
1. купить молоко

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

В чем основная сложность изучения программирования? Нужно много изучать, много кодить, много дебажить, много искать/исправлять багов.

А в чем прелесть? Все это можно делать самому, но в дружной компании может быть намного легче, например на курсе Профессия Python-разработчик от GB. Плюс прокачка командных скиллов, на реальной работе вы всегда будете в команде.

Реклама. Информация о рекламодателе по ссылкам в посте.

Пример простого AI-агента для отслеживания задач с использованием LangChain без OpenAI Function Calling. В этом примере мы вручную обрабатываем команды пользователя и выполняем соответствующие действия:

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

# Инициализация модели
llm = OpenAI(api_key="your-openai-api-key")

# Шаблон для запроса
template = """
Ты помощник для отслеживания задач. Ты можешь добавлять, показывать и удалять задачи.
Текущие задачи: {tasks}
Команда пользователя: {user_input}
Ответ:
"""

prompt = PromptTemplate(input_variables=["tasks", "user_input"], template=template)
chain = LLMChain(llm=llm, prompt=prompt)

# Переменная для хранения задач
tasks = []

# Обработка команд
def process_command(user_input):
    global tasks
    response = chain.run({"tasks": "\n".join(tasks), "user_input": user_input})
    
    # Простая логика обработки команд
    if "добавить" in user_input:
        task = user_input.split("добавить", 1)[1].strip()
        tasks.append(task)
        return f"Задача '{task}' добавлена."
    elif "показать" in user_input:
        return "Список задач:\n" + "\n".join([f"{i+1}. {task}" for i, task in enumerate(tasks)])
    elif "удалить" in user_input:
        try:
            task_index = int(user_input.split("удалить")[1].strip()) - 1
            removed_task = tasks.pop(task_index)
            return f"Задача '{removed_task}' удалена."
        except (ValueError, IndexError):
            return "Ошибка: Неверный индекс задачи."
    return response

# Пример взаимодействия
while True:
    user_input = input("Введите команду: ")
    if user_input.lower() in ["exit", "quit"]:
        print("До свидания!")
        break
    print(process_command(user_input))

Как работает:
- Агент использует LangChain для интеграции с OpenAI, обрабатывает команды пользователя и выполняет действия.
- Логика добавления, получения и удаления задач реализована вручную.

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

Пример кода, который демонстрирует, как можно создать векторное представление строки и сохранить его в ChromaDB с использованием библиотеки Chroma для работы с базой данных векторов.

Шаги:
1. Создаём векторное представление строки с использованием модели для эмбеддингов (например, OpenAI или Hugging Face).
2. Сохраняем вектор в базу данных Chroma.
3. Выполняем поиск по базе данных для демонстрации того, как можно извлечь похожие строки.

Установка необходимых зависимостей:

pip install chromadb openai langchain

### Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Инициализация Chroma клиента
client = chromadb.Client()

# Создание коллекции в Chroma
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Пример строки
text = "Это пример задачи для отслеживания векторного представления."

# Генерация векторного представления текста
vector = embeddings.embed_query(text)

# Сохраняем вектор и текст в Chroma
collection.add(
    documents=[text],  # Исходный текст
    embeddings=[vector],  # Векторное представление текста
    metadatas=[{"source": "example"}],  # Метаданные, если необходимо
    ids=["task_1"],  # Уникальный идентификатор для документа
)

# Поиск похожих векторов
query = "Найти похожие задачи"
query_vector = embeddings.embed_query(query)

# Выполнение поиска
results = collection.query(
    query_embeddings=[query_vector],  # Вектор запроса
    n_results=3  # Количество результатов для поиска
)

# Печать результатов
print("Результаты поиска:")
for result in results['documents']:
    print(result)

Объяснение:

1. Chroma Client и коллекция: Мы создаём клиент для Chroma и коллекцию, в которой будут храниться документы с векторными представлениями.
2. Эмбеддинги с OpenAI: Для создания векторов текста используется модель OpenAIEmbeddings.
3. Добавление данных: Вектор и сам текст добавляются в Chroma коллекцию с уникальным идентификатором.
4. Поиск: Запрос также преобразуется в вектор, и выполняется поиск по сохранённым векторным представлениям для нахождения наиболее похожих документов.

### Пример вывода:

Результаты поиска:
Это пример задачи для отслеживания векторного представления.

В результате будет возвращён текст, который наиболее похож на запрос, векторное представление которого мы создали.

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

Весна в разгаре, как и скидки на GB на курс Профессия Python-разработчик 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

Для создания модели генерации, использующей ChromaDB для поиска наиболее релевантных документов, а затем генерации ответа, можно объединить векторное представление с генерацией текста через модель вроде GPT или другую. Мы будем искать похожие документы в ChromaDB, извлекать их и использовать для генерации ответа.

Шаги:
1. Используем ChromaDB для поиска схожих документов по запросу.
2. Генерируем ответ на основе найденных документов с помощью модели генерации (например, GPT-3 или GPT-4).
3. Объединяем текст найденных документов и генерируем более полный и контекстный ответ.

Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.vectorstores import Chroma
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Инициализация Chroma клиента и создания коллекции
client = chromadb.Client()
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Пример текста и сохранение в Chroma
text = "Это пример задачи для отслеживания векторного представления."
vector = embeddings.embed_query(text)
collection.add(
    documents=[text],
    embeddings=[vector],
    metadatas=[{"source": "example"}],
    ids=["task_1"]
)

# Инициализация модели генерации (OpenAI GPT)
llm = OpenAI(api_key="your-openai-api-key")

# Создание шаблона запроса для генерации
prompt_template = """
Ты помощник для отслеживания задач. Вот несколько связанных документов:
{documents}
Пользовательский запрос: {user_input}
Ответ:
"""

# Создание цепочки для генерации текста
prompt = PromptTemplate(input_variables=["documents", "user_input"], template=prompt_template)
chain = LLMChain(llm=llm, prompt=prompt)

# Функция для поиска и генерации ответа
def generate_answer(user_input):
    # Получаем вектор запроса
    query_vector = embeddings.embed_query(user_input)

    # Выполняем поиск по базе данных Chroma
    results = collection.query(
        query_embeddings=[query_vector],  # Вектор запроса
        n_results=3  # Количество результатов
    )
    
    # Формируем текст, который будет передан в модель для генерации
    documents = "\n".join(results['documents'])
    
    # Генерируем ответ на основе найденных документов
    response = chain.run({
        "documents": documents,
        "user_input": user_input
    })
    
    return response

# Пример использования
user_input = "Что мне нужно сделать для отслеживания задач?"
response = generate_answer(user_input)
print("Ответ генератора:", response)

Объяснение:

1. Создание векторного представления:
- Мы генерируем векторное представление для документа и добавляем его в ChromaDB.

2. Поиск в ChromaDB:
- При поступлении запроса от пользователя мы создаём его векторное представление.
- Далее мы выполняем поиск по ChromaDB, чтобы найти наиболее релевантные документы на основе их векторных представлений.

3. Генерация ответа:
- Мы передаём найденные документы в модель генерации (например, GPT-3/4), которая использует их для формирования ответа на основе запроса.

4. Интеграция с LangChain:
- Используется LLMChain для генерации текста на основе найденных документов.

Пример вывода:

Ответ генератора: 
1. Обратите внимание на описание задачи в системе отслеживания.
2. Просмотрите список задач, чтобы убедиться, что они актуальны.
3. Если необходимо, добавьте новые задачи для обработки.

В результате модель использует информацию из ChromaDB для создания более контекстуализированного ответа.

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

Для демонстрации разницы между представлениями GraphChain и обычными цепочками (например, LLMChain**) в **LangChain, мы можем создать два разных подхода и визуализировать, как они используют вектора и графы для обработки запроса.

1. LLMChain — это простая цепочка, в которой один этап приводит к следующему (например, запрос -> векторизация -> генерация).
2. GraphChain — это более сложная структура, которая использует несколько взаимосвязанных шагов, представляя запрос как граф с множеством узлов, где каждый узел может выполнять различные операции (например, преобразования данных, вызовы внешних сервисов и т. д.).

В этом примере мы:
- Сначала продемонстрируем, как работает LLMChain с векторами.
- Затем создадим GraphChain для обработки того же запроса и визуализируем граф.

Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, GraphChain
from langchain.graphs import Graph

import matplotlib.pyplot as plt

# Инициализация Chroma клиента
client = chromadb.Client()

# Создание коллекции в Chroma
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Инициализация модели генерации (OpenAI GPT)
llm = OpenAI(api_key="your-openai-api-key")

# Пример текста и сохранение в Chroma
text = "Это пример задачи для отслеживания векторного представления."
vector = embeddings.embed_query(text)
collection.add(
    documents=[text],
    embeddings=[vector],
    metadatas=[{"source": "example"}],
    ids=["task_1"]
)

# Создание LLMChain для генерации ответа
llm_prompt = PromptTemplate(input_variables=["user_input"], template="Пользовательский запрос: {user_input}")
llm_chain = LLMChain(llm=llm, prompt=llm_prompt)

# Создание GraphChain с несколькими шагами
graph = Graph()

# Шаг 1: Получаем вектор запроса
graph.add_node("vectorize", embeddings.embed_query, input_variables=["user_input"])

# Шаг 2: Используем вектор для генерации ответа
graph.add_node("generate", lambda vector: llm_chain.run({"user_input": vector}), input_variables=["vectorize"])

# Создание GraphChain с использованием Graph
graph_chain = GraphChain(graph=graph)

# Пример запроса
user_input = "Что мне нужно сделать для отслеживания задач?"

# 1. Демонстрация LLMChain
response_llm = llm_chain.run({"user_input": user_input})

# 2. Демонстрация GraphChain
response_graph = graph_chain.run({"user_input": user_input})

# Печать результатов
print(f"Ответ LLMChain: {response_llm}")
print(f"Ответ GraphChain: {response_graph}")

# Визуализация графа
fig, ax = plt.subplots(figsize=(8, 6))
graph.visualize(ax=ax, node_color='lightblue', font_size=12, edge_color='gray')
plt.title("LangChain GraphChain")
plt.show()

Объяснение:

1. LLMChain:
- Мы создаём LLMChain, который использует вектор запроса для генерации ответа с помощью OpenAI GPT.
- Ответ генерируется в один шаг, а запрос передаётся модели для обработки.

2. GraphChain:
- Мы создаём GraphChain, который работает как граф с двумя узлами:
- Первый узел генерирует вектор запроса.
- Второй узел использует этот вектор для генерации ответа с помощью LLMChain.
- Это позволяет создать сложную логику, где один узел зависит от другого.

3. Визуализация графа:
- Визуализируется сам GraphChain, где можно увидеть взаимосвязь между различными узлами (например, один шаг для векторизации и другой для генерации текста).

Пример вывода:

Ответ LLMChain: Это пример задачи для отслеживания векторного представления.
Ответ GraphChain: Это пример задачи для отслеживания векторного представления.

Таким образом, вы можете видеть, как GraphChain даёт больше гибкости для работы с несколькими шагами, в отличие от более простого LLMChain, который выполняет последовательные операции.

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

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

Давайте рассмотрим, как можно использовать spaCy для разметки текста и как она может помочь:

Шаги:
1. Токенизация — Разделение текста на отдельные слова или токены.
2. Часть речи (POS) — Определение частей речи (существительное, глагол и т.д.).
3. Зависимости — Определение связей между словами в предложении.
4. Извлечение сущностей — Выделение именованных сущностей (например, людей, организаций, дат).

Установка spaCy:

pip install spacy
python -m spacy download ru_core_news_sm

Пример кода:

import spacy

# Загружаем модель для русского языка
nlp = spacy.load("ru_core_news_sm")

# Пример текста
text = """
Привет, меня зовут Александр. Я работаю в компании Оккципитал, и сегодня 10 марта 2025 года мы проводим встречу по задачам.
"""

# Применяем модель spaCy к тексту
doc = nlp(text)

# 1. Токенизация (разбиение текста на токены)
print("Токены:")
for token in doc:
    print(token.text)

# 2. Определение частей речи (POS)
print("\nЧасти речи:")
for token in doc:
    print(f"{token.text}: {token.pos_}")

# 3. Разбор зависимостей
print("\nЗависимости:")
for token in doc:
    print(f"{token.text} -> {token.dep_} ({token.head.text})")

# 4. Извлечение именованных сущностей (NER)
print("\nСущности:")
for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")

Объяснение:

1. Токенизация: В процессе токенизации текст разбивается на отдельные слова и знаки препинания. Это позволяет работать с каждым элементом текста отдельно.

2. Части речи: Каждое слово получает метку части речи. Например, существительные, глаголы, прилагательные и т. д. Это полезно для анализа синтаксической структуры текста.

3. Зависимости: Зависимости помогают понять, как слова связаны друг с другом в предложении. Это позволяет глубже понять структуру предложений и их смысл.

4. Извлечение сущностей: С помощью NER (Named Entity Recognition) можно извлекать важную информацию, такую как имена людей, названия компаний, даты и другие ключевые данные.

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

Пример вывода кода выше 👆👆👆

Токены:
Привет
,
меня
зовут
Александр
.
Я
работаю
в
компании
Оккципитал
,
и
сегодня
10
март
2025
года
мы
проводим
встречу
по
задачам
.

Части речи:
Привет: INTJ
,: PUNCT
меня: PRON
зовут: VERB
Александр: PROPN
.: PUNCT
Я: PRON
работаю: VERB
в: ADP
компании: NOUN
Оккципитал: PROPN
,: PUNCT
и: CCONJ
сегодня: ADV
10: NUM
март: NOUN
2025: NUM
года: NOUN
мы: PRON
проводим: VERB
встречу: NOUN
по: ADP
задачам: NOUN
.: PUNCT

Зависимости:
Привет -> intj (зовут)
, -> punct (Привет)
меня -> nsubj (зовут)
зовут -> ROOT (зовут)
Александр -> attr (зовут)
. -> punct (зовут)
Я -> nsubj (работаю)
работаю -> ROOT (работаю)
в -> prep (работаю)
компании -> pobj (в)
Оккципитал -> compound (компании)
, -> punct (работаю)
и -> cc (проводим)
сегодня -> advmod (проводим)
10 -> nummod (март)
март -> npadvmod (проводим)
2025 -> nummod (года)
года -> pobj (по)
мы -> nsubj (проводим)
проводим -> ROOT (проводим)
встречу -> obj (проводим)
по -> prep (проводим)
задачам -> pobj (по)

Сущности:
Александр: PER
Оккципитал: ORG
10 марта 2025 года: DATE

Как это может помочь:

1. Токенизация: Позволяет вам работать с текстом на более низком уровне, разбивая его на элементы. Это полезно для анализа частотности слов, выполнения других операций на токенах.

2. Части речи: Знание частей речи помогает в более точном понимании контекста. Например, если вам нужно выделить все глаголы или существительные в тексте, это поможет вам быстрее ориентироваться.

3. Зависимости: Понимание зависимостей между словами полезно для глубокого анализа текста, например, для понимания, кто выполняет действие, на что направлено действие, и т. д. Это может быть полезно для задач, таких как парсинг предложений и создание сложных вопросов и ответов.

4. Извлечение сущностей (NER): Это ключевой момент для извлечения фактов из текста. Например, можно извлечь имя человека, организацию, дату события и другие важные данные. Эти сущности могут быть полезны для создания баз данных, анализа, или генерации ответов на вопросы.

### Пример использования в AI-агенте:

1. Извлечение информации: Если вы разрабатываете AI-агента для поддержки, например, в сфере IT, вы можете использовать spaCy для извлечения версий программного обеспечения, дат, имен сотрудников или других ключевых данных, которые затем можно использовать для создания отчетов или для ответа на вопросы пользователя.

2. Предобработка текста для генерации: Разметка с использованием spaCy может улучшить точность генерации текста. Например, перед тем как сгенерировать ответ, можно использовать токенизацию и анализ зависимостей для точного понимания, какие части запроса являются самыми важными.

Таким образом, spaCy предоставляет инструменты для извлечения важной информации из текста и помогает лучше понять структуру и смысл текста.

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