Как (и почему) я создал ИИ-помощника
В этой статье я честно расскажу о том, почему я создал собственного ИИ-помощника, а не просто купил готового, опишу его архитектуру, код, что сломалось и что он теперь делает, на что я действительно полагаюсь.
# Введение
Всё началось с того, что вторник пролетел незаметно. Мне нужно было подвести итоги трёх клиентских брифов, открыть множество вкладок с исследовательскими материалами, которые я постоянно обещала себе открыть, ответить на несколько писем, требующих вдумчивого ответа, и продержаться почти четыре дня в одной из открытых вкладок с наполовину написанным техническим документом. К тому времени, как я наконец оторвалась от всего этого, переключаясь между вкладками, было уже больше 7 вечера, а я так и не выпустила ничего значимого.
В тот вечер, вместо того чтобы закрыть ноутбук и признать поражение, я начал по-другому взглянуть на проблему. Нехватки времени было недостаточно. Нехватки рычагов воздействия. Каждую задачу, которую я выполнял в тот день, можно было бы делегировать чему-то более эффективному, чем закладка в браузере. Поэтому я начал создавать собственное решение.
Эта статья — честный рассказ о процессе создания собственного ИИ-помощника, а не о том, чтобы просто купить готовый, как выглядит его архитектура, какой был код, что сломалось и что он теперь делает, на что я действительно полагаюсь.
# Вопрос «Почему» стоит перед вопросом «Как»
Большинство людей, решивших создать ИИ-помощника, начинают с поиска в Google «учебник по Python LangChain». Это неправильно. Первый вопрос, над которым стоит задуматься: зачем вообще это создавать, если уже существуют Siri, ChatGPT, Copilot и десяток других инструментов?
Для меня честным ответом был контроль. Не в смысле паранойи или отчуждения, а в практическом смысле, ведь любой готовый ассистент разрабатывается с учетом чужих представлений о ваших потребностях. Они по своей сути универсальны, а универсальность подразумевает компромиссы. Мне же нужно было что-то, что учитывало бы мой контекст, использовало бы мой тон, было бы связано с моими конкретными инструментами и оставалось бы в рамках рабочего процесса, которому я уже доверяю.
Есть ещё и вопрос данных. Когда вы используете стороннего помощника, ваши подсказки и контекст проходят через его инфраструктуру. Для личной продуктивности это, пожалуй, нормально. Но для всего, что связано с клиентами или коммерческой тайной, ситуация становится сложнее. Создание собственного помощника означает, что вы сами решаете, где будут храниться данные.
А еще есть аргумент о кривой обучения, который, как мне кажется, часто недооценивают: вы гораздо лучше понимаете инструмент, когда создаете его сами. Когда что-то ломается, вы знаете, где искать проблему. Когда вам нужно, чтобы он делал что-то новое, вы не ждете обновления продукта.
Выбор времени также облегчил обоснование решения. По данным MarketsandMarkets , рынок ИИ-помощников, по прогнозам, вырастет с 3,35 млрд долларов в 2025 году до 21,11 млрд долларов к 2030 году — среднегодовой темп роста составляет 44,5%. Такая траектория говорит о том, что эта технология — не просто тренд, а инфраструктура. Освоив её сейчас, создавая, а не просто потребляя, вы опередите большинство людей через два года.
Тем не менее, самостоятельная разработка не всегда является правильным решением. Если вам нужен быстрый инструмент для поиска ответов или вспомогательное средство для письма за 20 долларов в месяц, купите его. Но если вам нужно что-то, что интегрируется с вашим реальным рабочим процессом, учится на ваших предпочтениях и обрабатывает задачи способом, специфичным для вашей работы, то стоит разработать это самостоятельно.
# Выбор стека
После того, как я решил построить дом, следующим шагом стало решение, из чего его построить. Вот что я действительно рассматривал, а не какая-то общая сравнительная таблица.
- В рамках программы LLM выбор сводился к двум серьезным вариантам: GPT-4o от OpenAI и Claude от Anthropic . Я протестировал оба инструмента с одинаковыми задачами в области исследований, написания текстов и логического мышления. GPT-4o работает быстро и обладает широкими возможностями, а также зрелым API. Claude особенно хорошо справляется с длинными документами и сложными инструкциями. В итоге я выбрал GPT-4o в качестве основной модели из-за надежности вызова инструментов и зрелости экосистемы, а Claude доступен в качестве резервного варианта для некоторых задач, требующих работы с большими объемами документов.
- Для оркестровки я выбрал LangChain . В кругах разработчиков ведутся споры о том, не добавляет ли LangChain слишком много абстракций, и эта критика не лишена оснований. Но для такого проекта, как этот — требующего памяти, использования инструментов и цикла логического вывода — абстракции LangChain экономят реальное время. Альтернатива — писать всю эту инфраструктуру самостоятельно, что можно сделать, но это не то, на что следует обращать внимание, когда вы пытаетесь выпустить что-то функциональное.
- Память была обязательным требованием с самого начала. Чат-бот без сохранения состояния, который забывает все данные между сессиями, полезен для разовых вопросов. Он не подходит для полноценного голосового помощника. ConversationBufferMemory от LangChain отлично работал для контекста внутри сессии. Для сохранения данных между сессиями я использовал простой подход на основе SQLite, который я покажу в разделе кода.
- Что касается инструментов, я наделил ассистента возможностью поиска в интернете (через API DuckDuckGo — ключ не требуется), чтения и обобщения переданных ему файлов, а также вызова написанных мной пользовательских функций на Python для выполнения конкретных повторяющихся задач. Именно здесь кроется настоящая ценность: превращение его из чат-бота в нечто, способное реально что-то делать.
Четкая горизонтальная блок-схема архитектуры стека.
# Настройка среды
Перед запуском любого кода вам понадобятся три вещи: Python 3.10 или выше, виртуальное окружение и ваши API-ключи, надежно сохраненные.
Шаг 1: Создание и активация виртуальной среды
# Создание виртуальной среды с именем 'assistant_env' python -m venv assistant_env # Активация в macOS/Linux source assistant_env/bin/activate # Активация в Windows assistant_envScriptsactivate
Виртуальная среда изолирует зависимости вашего проекта от всего остального на вашем компьютере. Это важнее, чем кажется — конфликты зависимостей между проектами являются распространенным, скрытым источником ошибок.
Шаг 2: Установка необходимых пакетов
pip install langchain==0.3.0 langchain-openai langchain-community langgraph duckduckgo-search python-dotenv pydantic requests
Вот что делает каждый пакет:
- Langchain — это базовая структура, которая связывает ваши LLM-файлы, память и инструменты.
- langchain-openai — это специализированный коннектор для моделей OpenAI.
- langchain-community предоставляет доступ к инструментам и интеграциям, созданным сообществом, включая поиск DuckDuckGo.
- Langgraph обрабатывает более сложные рабочие процессы агентов с сохранением состояния.
- duckduckgo-search позволяет ассистенту осуществлять поиск в интернете без необходимости использования ключа API.
- python-dotenv загружает ваши API-ключи из файла .env, а не прописывает их вручную.
- Pydantic выполняет проверку достоверности данных для структурированных входных и выходных данных.
Шаг 3: Безопасное хранение ключей API
Никогда не вставляйте ключ API непосредственно в скрипт. Создайте файл .env в корневой директории вашего проекта:
# Файл .env — никогда не добавляйте это в систему контроля версий OPENAI_API_KEY=ваш_ключ_openai_здесь
Затем немедленно добавьте .env в ваш файл .gitignore:
# .gitignore .env assistant_env/ __pycache__/
# Создание основного помощника
Вот здесь все и складывается воедино. Я пройдусь по каждому компоненту в том порядке, в котором его необходимо собрать.
- Подключение к языковой модели # assistant.py import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI # Загрузка переменных окружения из файла .env load_dotenv() # Инициализация языковой модели # temperature управляет случайностью: 0 = сфокусированная и детерминированная, 1 = более креативная # Для помощника, которому необходима точность и согласованность, держите это значение низким (от 0,1 до 0,3) llm = ChatOpenAI( model=»gpt-4o», temperature=0.2, api_key=os.getenv(«OPENAI_API_KEY») )
Что это делает: ChatOpenAI устанавливает соединение с GPT-4o через API. Параметр «температура» заслуживает внимания: при значении 0 модель всегда выбирает наиболее вероятный следующий токен, что приводит к очень стабильному, но иногда жесткому результату. При значении 1 результат гораздо более разнообразный и креативный. Для голосового помощника, ориентированного на выполнение задач, значение от 0,1 до 0,3 обеспечивает надежность без потери качества естественного языка.
- Разработка системной подсказки
Системные подсказки — самая недооцененная часть всей системы. Они определяют характер вашего ассистента, его ограничения и то, как он обрабатывает неоднозначные ситуации. Уделите этому моменту больше времени, чем вам кажется необходимым.
# Системная подсказка служит постоянными инструкциями для вашего ассистента. # Она отправляется в начале каждого разговора, чтобы закрепить его поведение. SYSTEM_PROMPT = «»» Вы — целеустремленный и надежный личный ассистент. Ваша задача — помогать пользователю исследовать темы, резюмировать документы, составлять письменные тексты и выполнять структурированные задачи. Вы всегда: — Даете прямые ответы, прежде чем уточнять — Говорите, когда не уверены, вместо того, чтобы гадать — Запрашиваете уточнение, если задача действительно неоднозначна — Делаете ответы краткими, если только не запрашиваются подробности. У вас есть доступ к веб-поиску, и вы можете читать файлы, предоставленные пользователем. При использовании этих инструментов всегда указывайте источники информации. Не выдумывайте факты, не придумывайте цитаты и не заполняйте пробелы правдоподобно звучащей выдумкой. «»»
Что это делает: Эта подсказка отправляется перед каждым разговором. Представьте это как должностную инструкцию, которую вы бы дали помощнику в его первый рабочий день. Чем конкретнее она будет, тем меньше вам придется поправлять модель в середине разговора. Расплывчатые инструкции всегда приводят к расплывчатому поведению.
- Добавление памяти
Без функции памяти ваш ассистент забывает все, как только вы начинаете новое сообщение. Вот как это исправить.
from langchain.memory import ConversationBufferMemory from langchain_community.chat_message_histories import SQLChatMessageHistory # SQLChatMessageHistory хранит историю разговоров в локальной базе данных SQLite. # session_id позволяет поддерживать отдельные потоки памяти (например, один на проект). message_history = SQLChatMessageHistory( session_id=»main_session», connection_string=»sqlite:///assistant_memory.db» ) # ConversationBufferMemory оборачивает историю сообщений и передает ее LLM # на каждом ходу, чтобы модель знала, что было сказано ранее. memory = ConversationBufferMemory( memory_key=»chat_history», chat_memory=message_history, return_messages=True )
Что это делает: SQLChatMessageHistory сохраняет каждый обмен сообщениями в локальный файл SQLite под названием assistant_memory.db. Это означает, что ваш ассистент запоминает контекст между сессиями. session_id — это просто метка; вы можете создать несколько сессий для разных проектов или тем, и они останутся полностью независимыми друг от друга.
Одно важное замечание: буферная память хранит всю историю и в конечном итоге достигнет предела контекста модели при длительных диалогах. Для использования в производственной среде ConversationSummaryMemory — лучший выбор: он сжимает старую историю в краткое изложение, позволяя оставаться в пределах лимита токенов.
- Предоставление инструментов для решения задач
Именно это отличает чат-бота от голосового помощника. Инструменты позволяют модели совершать реальные действия.
from langchain.agents import AgentExecutor, create_openai_tools_agent from langchain_community.tools import DuckDuckGoSearchRun from langchain.tools import tool from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder # Инструмент 1: Веб-поиск через DuckDuckGo — ключ API не требуется search_tool = DuckDuckGoSearchRun() # Инструмент 2: Пользовательский считыватель файлов, который вы определяете сами # Декоратор @tool регистрирует эту функцию как то, что может вызывать агент @tool def read_file(file_path: str) -> str: «»» Читает текстовый файл по указанному пути и возвращает его содержимое. Используйте это, когда пользователь просит вас прочитать, проанализировать или резюмировать файл. «»» try: with open(file_path, «r», encoding=»utf-8″) as f: return f.read() except FileNotFoundError: return f»File not найдено: {путь_к_файлу}» except Exception as e: return f»Ошибка чтения файла: {str(e)}» # Регистрация инструментов, которые может использовать агент tools = [search_tool, read_file] # Создание шаблона подсказки # MessagesPlaceholder размещает в памяти (история чата) и в блокноте агента prompt = ChatPromptTemplate.from_messages([ («system», SYSTEM_PROMPT), MessagesPlaceholder(variable_name=»chat_history»), («human», «{input}»), MessagesPlaceholder(variable_name=»agent_scratchpad») ]) # Создание агента — это объединяет LLM, инструменты и подсказку agent = create_openai_tools_agent(llm, tools, prompt) # AgentExecutor — это цикл выполнения: он вызывает агента, запускает любые выбранные им инструменты, # передает результаты обратно и повторяет до тех пор, пока не получит окончательный ответ agent_executor = AgentExecutor( agent=agent, tools=tools, memory=memory, verbose=True, # Установите значение False в рабочей среде; True позволяет видеть этапы логического вывода max_iterations=5 # Предотвращает зацикливание агента при решении сложных задач )
Что это делает: AgentExecutor — это движок. Когда вы отправляете ему сообщение, он не просто передает его в LLM и возвращает то, что приходит в голову. Он запускает цикл: модель решает, нужно ли ей использовать инструмент, вызывает инструмент, если да, получает результат, обдумывает, что делать дальше, и возвращает окончательный ответ только тогда, когда он удовлетворен. Это и есть паттерн ReAct (Рассуждение + Действие) на практике.
Схема кругового цикла, показывающая четыре обозначенных этапа, соединенных стрелками.
В итоге, вот основной цикл выполнения:
def chat(user_input: str) -> str: «»» Отправьте сообщение помощнику и получите ответ. Память обрабатывается автоматически агентом-исполнителем.»»» try: response = agent_executor.invoke({«input»: user_input}) return response[«output»] except Exception as e: # Корректная обработка ошибок — сообщает, что сломалось, не вызывая сбоя сессии return f»Что-то пошло не так: {str(e)}. Пожалуйста, попробуйте еще раз или переформулируйте свой запрос.» # Простой интерфейс командной строки для запуска помощника. Если __name__ == «__main__»: print(«Помощник готов. Введите 'quit' для выхода.n») while True: user_input = input(«Вы: «).strip() if user_input.lower() in [«quit», «exit», «q»]: print(«До свидания.») break if not user_input: continue response = chat(user_input) print(f»nПомощник: {response}n»)
Что делает эта функция: Функция chat() является единственной точкой входа для всей системы. Вы передаете ей строку, она обрабатывает все — извлечение данных из памяти, вызовы инструментов, логические рассуждения LLM, обработку ошибок — и возвращает строку. Блок if __name__ == «__main__» превращает весь скрипт в работающий помощник командной строки, который можно немедленно запустить с помощью python assistant.py.
# Тестирование и устранение неполадок
При первом запуске помощник выдал уверенный ответ, который был фактически неверным, проигнорировал инструмент, который следовало использовать, и отформатировал ответ так, как мне не понравилось. Ничего необычного в этом нет. Это не признак того, что сборка не работает — это начало настоящей работы.
Самое важное на раннем этапе — проверить, действительно ли агент использует свои инструменты, когда это необходимо. Распространённая ошибка — это попытка модели отвечать из памяти, когда ей следует осуществлять поиск, поскольку системная подсказка недостаточно явно указывала на это ожидание. Я исправил это, добавив в системную подсказку:
Отвечая на вопросы о недавних событиях, актуальных данных или любой информации, имеющей ограниченный срок действия, всегда используйте инструмент поиска в интернете. Не полагайтесь на свои знания, полученные в ходе обучения, в отношении фактов, которые могли измениться.
Что касается обработки ошибок: это гораздо важнее, чем кажется из большинства руководств. Согласно исследованию Mordor Intelligence , почти половина кода, сгенерированного ИИ, не проходит первую проверку безопасности. Тот же принцип применим и к ответам, сгенерированным ИИ — результат следует рассматривать как черновик, а не как окончательный ответ, пока вы не убедитесь в надежности конкретного типа задачи. Блок try/except в функции chat() выше — это начало, но вы захотите расширить его по мере того, как будете обнаруживать конкретные ошибки, которые допускает ваш ассистент.
Для более структурированного тестирования пишите тестовые примеры следующим образом:
# test_assistant.py # Запустите эти тесты, чтобы убедиться, что помощник работает должным образом, прежде чем развертывать test_cases = [ { «input»: «Какова текущая цена биткоина?», «expected_behavior»: «Должен использоваться веб-поиск, а не ответ по памяти» }, { «input»: «Краткое изложение файла по адресу /tmp/test_document.txt», «expected_behavior»: «Должен вызываться инструмент read_file» }, { «input»: «Что я спрашивал у вас пять сообщений назад?», «expected_behavior»: «Должен корректно ссылаться на память разговора» } ] for case in test_cases: print(f»Тестирование: {case['input']}») print(f»Ожидаемое: {case['expected_behavior']}») result = chat(case[«input»]) print(f»Получено: {result[:200]}…») # Вывести первые 200 символов ответа print(«—«)
Выполните эти действия после любых изменений в командной строке системы или конфигурации инструментов. Небольшие изменения в командной строке часто приводят к неожиданным последствиям.
# Полный код
Всё вышеописанное объяснялось по частям. Здесь же представлен один полный файл, готовый к копированию и вставке. Сохраните его как assistant.py, убедитесь, что ваш файл .env находится в той же директории, и запустите его с помощью команды `python assistant.py`.
# assistant.py # Полноценный ИИ-помощник — создан с использованием LangChain, GPT-4o, поиска DuckDuckGo и памяти SQLite # Требования: Python 3.10+ | Запуск: pip install langchain==0.3.0 langchain-openai # langchain-community langgraph duckduckgo-search python-dotenv pydantic requests import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI from langchain.memory import ConversationBufferMemory from langchain_community.chat_message_histories import SQLChatMessageHistory from langchain.agents import AgentExecutor, create_openai_tools_agent from langchain_community.tools import DuckDuckGoSearchRun from langchain.tools import tool from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder # ───────────────────────────────────────────── # 1. ЗАГРУЗКА ПЕРЕМЕННЫХ СРЕДЫ # ───────────────────────────────────────────── # Считывает OPENAI_API_KEY из вашего файла .env. # Никогда не прописывайте ключи API напрямую в исходном коде. load_dotenv() # ──────────────────────────────────────────── # 2. ИНИЦИАЛИЗАЦИЯ ЯЗЫКОВОЙ МОДЕЛИ # ────────────────────────────────────────────── # Значение temperature=0.2 обеспечивает целенаправленный и последовательный ответ. # Увеличьте его до 1.0, если хотите получить более креативный и разнообразный результат. llm = ChatOpenAI( model=»gpt-4o», temperature=0.2, api_key=os.getenv(«OPENAI_API_KEY») ) # ────────────────────────────────────────────── # 3. ОПРЕДЕЛЕНИЕ СИСТЕМНОЙ ПОДСКАЗКИ # ────────────────────────────────────────────── # Это набор постоянных инструкций для ассистента. # Он формирует поведение на каждом этапе — относитесь к нему внимательно. SYSTEM_PROMPT = «»» Вы — целеустремленный и надежный личный помощник. Ваша задача — помогать пользователю в поиске информации по различным темам, составлении резюме документов, написании текстов и выполнении структурированных задач. Вы всегда: — Даете прямые ответы, прежде чем уточнять; — Говорите, когда не уверены, вместо того, чтобы гадать; — Запрашиваете уточнения, если задача действительно неоднозначна; — Делаете ответы краткими, если не запрашиваются подробности. У вас есть доступ к веб-поиску, и вы можете читать файлы, предоставленные пользователем. При использовании этих инструментов всегда указывайте источник информации. При ответе на вопросы о недавних событиях, текущих данных или любой информации, актуальной на данный момент, всегда используйте инструмент веб-поиска. Не полагайтесь на свои знания, полученные в ходе обучения, в отношении фактов, которые могли измениться. Не выдумывайте факты, не придумывайте цитаты и не заполняйте пробелы правдоподобно звучащей выдумкой. «»» # ───────────────────────────────────────────── # 4. СОЗДАЙТЕ ПОСТОЯННУЮ ПАМЯТЬ # ────────────────────────────────────────────── # SQLChatMessageHistory сохраняет историю разговоров в локальной базе данных SQLite. # Это означает, что помощник запоминает контекст между сессиями, а не только в рамках одной. # Измените session_id, чтобы использовать отдельные потоки памяти (например, один на проект). message_history = SQLChatMessageHistory( session_id=»main_session», connection_string=»sqlite:///assistant_memory.db» ) # ConversationBufferMemory оборачивает историю сообщений и внедряет ее # в каждый запрос, чтобы модель всегда имела полный контекст разговора. # Примечание: для очень длинных разговоров замените это на ConversationSummaryMemory, # чтобы избежать превышения лимита токенов модели. memory = ConversationBufferMemory( memory_key=»chat_history», chat_memory=message_history, return_messages=True ) # ───────────────────────────────────────────── # 5. ОПРЕДЕЛЕНИЕ ИНСТРУМЕНТОВ # ────────────────────────────────────────────── # Инструмент 1: Веб-поиск через DuckDuckGo — ключ API не требуется search_tool = DuckDuckGoSearchRun() # Инструмент 2: Пользовательский считыватель файлов # Декоратор @tool регистрирует эту функцию Python как вызываемый инструмент, # который агент может вызвать, когда пользователь попросит его прочитать файл. @tool def read_file(file_path: str) -> str: «»» Читает текстовый файл по указанному пути и возвращает его содержимое. Используйте это, когда пользователь просит вас прочитать, проанализировать или обобщить файл. «»» try: with open(file_path, «r», encoding=»utf-8″) as f: return f.read() except FileNotFoundError: return f»Файл не найден: {file_path}» except Exception as e: return f»Ошибка чтения файла: {str(e)}» # Собираем все инструменты в список — добавляйте сюда новые пользовательские инструменты по мере их создания tools = [search_tool, read_file] # ───────────────────────────────────────────── # 6. СОЗДАЙТЕ АГЕНТА # ────────────────────────────────────────────── # Шаблон подсказки структурирует каждое сообщение, отправляемое модели. # MessagesPlaceholder размещает данные в памяти (chat_history) и во внутреннем блокноте агента # для анализа рассуждений на каждом ходу. prompt = ChatPromptTemplate.from_messages([ («system», SYSTEM_PROMPT), MessagesPlaceholder(variable_name=»chat_history»), («human», «{input}»), MessagesPlaceholder(variable_name=»agent_scratchpad») ]) # create_openai_tools_agent объединяет LLM, инструменты и подсказку # в единого агента, который знает, когда и какие инструменты вызывать. agent = create_openai_tools_agent(llm, tools, prompt) # AgentExecutor — это цикл выполнения. # Он вызывает агента, запускает любые выбранные им инструменты, передает результаты обратно # и повторяет процесс, пока не получит окончательный ответ (или не достигнет max_iterations). agent_executor = AgentExecutor( agent=agent, tools=tools, memory=memory, verbose=True, # В производственной среде установите значение False; True отображает этапы обработки max_iterations=5 # Предотвращает бесконечное зацикливание агента на сложных задачах ) # ────────────────────────────────────────────────── # 7. ФУНКЦИЯ ЧАТА # ───────────────────────────────────────────── def chat(user_input: str) -> str: «»» Отправляет сообщение помощнику и получает ответ. Здесь управляются память, использование инструментов и обработка ошибок. «»» try: response = agent_executor.invoke({«input»: user_input}) return response[«output»] except Exception as e: # Возвращает читаемое сообщение об ошибке вместо сбоя сессии. # В производственной среде для отладки записывайте сюда полное исключение. return f»Что-то пошло не так: {str(e)}. Пожалуйста, попробуйте еще раз или переформулируйте свой запрос.» # ──────────────────────────────────────────────── # 8. ИНТЕРФЕЙС КОМАНДНОЙ СТРОКИ # ────────────────────────────────────────────── # Запустите этот файл напрямую, чтобы начать сеанс командной строки: python assistant.py # Чтобы обернуть его в пользовательский интерфейс браузера, см. Gradio или Streamlit в части 7. if __name__ == «__main__»: print(«Помощник готов. Введите 'quit' для выхода.n») while True: user_input = input(«Вы: «).strip() if user_input.lower() in [«quit», «exit», «q»]: print(«До свидания.») break if not user_input: continue response = chat(user_input) print(f»nАссистент: {response}n»)
// Результаты
После примерно двух недель регулярного использования вот что теперь делает для меня голосовой помощник:
- Синтез результатов исследования: я задаю тему и три-пять URL-адресов, а программа собирает ключевые моменты в структурированное резюме. То, что раньше занимало 45 минут, теперь занимает около 4 минут, а оставшееся время уходит на собственную проверку и оценку.
- Создание черновиков: Первые черновики электронных писем, резюме и структурированных документов. Итоговый вариант не является окончательным, и я не ожидаю, что он будет таковым, но иметь что-то для редактирования быстрее, чем каждый раз начинать с чистого листа.
- Обработка файлов: я помещаю протоколы совещаний, PDF-файлы и журналы в папку и прошу программу извлечь определенную информацию. Она надежно справляется с этим, если файлы текстовые и содержат менее 50 000 слов.
Экономия времени реальна. Данные анализа DX, проведенного среди более чем 135 000 разработчиков, показали, что в среднем использование инструментов ИИ позволяет сэкономить 3,6 часа в неделю, а у обычных пользователей экономия еще больше. Мой опыт показывает примерно такие же результаты в дни с высокой нагрузкой, хотя они сильно варьируются в зависимости от типа работы.
# Завершение
Тот самый вторник, о котором я писал в начале, — когда я работал весь день и почти ничего не отправил, — всё ещё случается. Но реже, и если случается, то редко из-за того, что я занимался не тем видом работы. Помощник занимается теми частями работы, которые не требуют моего участия, что позволяет мне уделять больше времени тем частям, которые действительно необходимы.
Чего я не ожидал, так это того, что создание этого инструмента изменило мое представление о самой работе. Когда ты отвечаешь за инструмент, начинаешь по-другому замечать препятствия. Начинаешь чаще спрашивать: «Можно ли это делегировать?», что является полезной ментальной привычкой независимо от того, задействован ли в этом ИИ.
Порог для создания чего-то подобного ниже, чем кажется. Полностью рабочий помощник, представленный выше, написан менее чем на 150 строках кода на Python, использует свободно доступные фреймворки и работает на любом компьютере с установленным Python. Самая сложная часть — решить, что именно вы хотите от него получить, и на этот вопрос стоит ответить тщательно, потому что целенаправленный помощник всегда лучше универсального.
Начните с малого. Дайте ему одну задачу. Добавляйте сложности только тогда, когда исчерпаете ценность более простого уровня. Такой подход работает как для инструментов, так и для формирования привычек, связанных с ними.
Шитту Олумиде — инженер-программист и технический писатель, увлеченный использованием передовых технологий для создания захватывающих повествований, обладающий острым вниманием к деталям и умением упрощать сложные концепты. Вы также можете найти Шитту в Твиттере.
Источник: www.kdnuggets.com
Оцените материал:
