Локальная нейросеть для Outlook и Facebook Marketplace: автоматизируем рутину без слежки и API-платежей

Почему платить за ChatGPT, если можно заставить нейросеть работать локально и бесплатно?

Вы тратите часы каждый день, отвечая на однотипные письма в Outlook и переписываясь с покупателями на Facebook Marketplace. "Уточните адрес", "Есть ли в наличии?", "Можете скинуть фото?" – вы могли бы отвечать на это с закрытыми глазами. Или могли бы поручить это нейросети.

Но есть проблема: отправлять клиентские данные в облако OpenAI – это как оставлять ключи от офиса под ковриком. Платить за API каждый раз, когда кто-то спрашивает про доставку – это как нанимать секретаря с почасовой оплатой для отправки шаблонных ответов.

Решение существует, и оно работает на вашем же компьютере. Локальная LLM (Large Language Model) плюс немного автоматизации – и вы получаете автоответчика, который не шпионит, не требует подписки и работает даже без интернета.

Что нам понадобится и почему именно это

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

Почему именно этот стек? Потому что он работает без танцев с бубном. Ollama против других локальных решений выигрывает в простоте, а Llama 3.2 – в качестве ответов при минимальных требованиях к ресурсам.

1 Ставим Ollama и загружаем модель – это проще, чем кажется

Первая ошибка новичков – пытаться собрать модель из исходников. Не делайте так. Ollama – это как App Store для нейросетей.

# Установка Ollama (Linux/macOS)
curl -fsSL https://ollama.ai/install.sh | sh

# Или скачайте установщик с сайта для Windows
# После установки проверяем:
ollama --version

# Качаем модель. На 2026 год Llama 3.2 7B – оптимальный выбор
ollama pull llama3.2:7b

# Проверяем, что работает
ollama run llama3.2:7b "Привет! Напиши 'работает' если ты функционируешь."

Видите ответ? Отлично. Теперь у вас на компьютере работает нейросеть, которая ничем не уступает ChatGPT для ваших задач. И она никуда не отправляет ваши данные.

2 Готовим Python-окружение и подключаемся к Ollama

Ollama работает как сервер. Мы будем отправлять ему запросы из Python. Никаких токенов OpenAI, только локальный HTTP.

# Создаем виртуальное окружение
python -m venv llm_automation
source llm_automation/bin/activate  # или llm_automation\Scripts\activate на Windows

# Ставим нужные библиотеки
pip install requests python-dotenv schedule

Теперь создадим простейший клиент для Ollama:

# ollama_client.py
import requests
import json

class OllamaClient:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url
    
    def generate(self, prompt, model="llama3.2:7b", system_prompt=None):
        """Отправляет промпт в Ollama и возвращает ответ"""
        payload = {
            "model": model,
            "prompt": prompt,
            "stream": False,
            "options": {
                "temperature": 0.3,  # Низкая температура для предсказуемых ответов
                "top_p": 0.9
            }
        }
        
        if system_prompt:
            payload["system"] = system_prompt
        
        response = requests.post(
            f"{self.base_url}/api/generate",
            json=payload,
            timeout=60
        )
        
        if response.status_code == 200:
            return response.json()["response"]
        else:
            raise Exception(f"Ollama error: {response.text}")

# Проверяем
client = OllamaClient()
test_response = client.generate("Классифицируй запрос: 'Здравствуйте, когда будет доставка?'")
print(f"Ответ модели: {test_response}")

Если видите осмысленный ответ – поздравляю, вы только что заменили OpenAI API на локальное решение. И сэкономили $0.002 на этом запросе.

3 Пишем промпты, которые действительно работают для бизнеса

Вот где большинство проваливается. Они пишут "ответь на это письмо" и удивляются, почему нейросеть генерирует ерунду. Бизнес-промпты – это инструкции с контекстом.

Для Outlook создаем system prompt (системную инструкцию):

OUTLOOK_SYSTEM_PROMPT = """Ты – автоответчик компании "ТехноМир", которая продает электронику.
Твои задачи:
1. Классифицировать входящие письма по категориям: ВОПРОС_О_ДОСТАВКЕ, ВОПРОС_О_НАЛИЧИИ, ЖАЛОБА, ПРЕДЛОЖЕНИЕ_О_СОТРУДНИЧЕСТВЕ, ДРУГОЕ
2. Формировать вежливые, но краткие ответы
3. В ответах использовать только факты из базы знаний:
- Доставка: 1-3 рабочих дня по Москве, 3-7 дней по регионам
- Оплата: картой онлайн, наличными при получении
- Гарантия: 1 год на всю технику
4. Если вопрос требует человеческого внимания (жалоба, сложный вопрос), отвечай: "Передам ваш вопрос менеджеру, он свяжется с вами в течение 2 часов."
5. Всегда подписывайся: "С уважением, команда ТехноМира"

Отвечай только на русском языке."""

Для Facebook Marketplace промпт будет другим:

MARKETPLACE_SYSTEM_PROMPT = """Ты – помощник по продажам на Facebook Marketplace.
Твои задачи:
1. Определять намерение покупателя: ВОПРОС_ЦЕНЫ, ВОПРОС_СОСТОЯНИЯ, ДОГОВОР_О_ВСТРЕЧЕ, СПАМ
2. Отвечать быстро и дружелюбно
3. Для вопросов о цене: "Цена фиксированная, но при самовывозе сегодня могу сделать скидку 5%"
4. Для вопросов о состоянии: "Телефон в идеальном состоянии, экран без царапин, батарея держит 2 дня. Могу снять видеообзор по запросу"
5. Для договора о встрече: "Предлагаю встретиться у метро [ближайшее_метро] сегодня после 18:00. Мой номер для связи: [номер_телефона]"
6. Спам игнорировать

Используй неформальный, но вежливый тон."""

Видите разницу? Это не просто "ответь на сообщение". Это должностная инструкция для цифрового сотрудника. И она работает в разы лучше.

4 Интегрируемся с Outlook через Microsoft Graph API

Не нужно устанавливать Outlook на сервер. Microsoft дает нормальный REST API. Регистрируем приложение в Azure Portal (бесплатно), получаем client_id и client_secret.

# outlook_client.py
import msal
import requests
from datetime import datetime, timedelta

class OutlookClient:
    def __init__(self, client_id, client_secret, tenant_id):
        self.client_id = client_id
        self.client_secret = client_secret
        self.tenant_id = tenant_id
        self.scopes = ["https://graph.microsoft.com/.default"]
        self.token = self._get_token()
    
    def _get_token(self):
        """Получаем access token для Microsoft Graph"""
        app = msal.ConfidentialClientApplication(
            self.client_id,
            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
            client_credential=self.client_secret
        )
        result = app.acquire_token_for_client(scopes=self.scopes)
        return result["access_token"]
    
    def get_unread_emails(self, top=10):
        """Получаем непрочитанные письма"""
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
        
        # Фильтруем письма за последние 24 часа
        time_filter = (datetime.utcnow() - timedelta(hours=24)).isoformat() + "Z"
        
        response = requests.get(
            f"https://graph.microsoft.com/v1.0/me/mailFolders/inbox/messages",
            headers=headers,
            params={
                "$filter": f"isRead eq false and receivedDateTime ge {time_filter}",
                "$top": top,
                "$select": "subject,bodyPreview,from,id"
            }
        )
        
        return response.json().get("value", [])
    
    def send_reply(self, email_id, reply_text):
        """Отправляем ответ на письмо"""
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "message": {
                "body": {
                    "contentType": "Text",
                    "content": reply_text
                }
            }
        }
        
        response = requests.post(
            f"https://graph.microsoft.com/v1.0/me/messages/{email_id}/reply",
            headers=headers,
            json=payload
        )
        
        return response.status_code == 202

Теперь связываем Outlook с нашей нейросетью:

# main_outlook_automation.py
from outlook_client import OutlookClient
from ollama_client import OllamaClient
import time

def process_outlook_emails():
    outlook = OutlookClient(
        client_id="YOUR_CLIENT_ID",
        client_secret="YOUR_CLIENT_SECRET",
        tenant_id="YOUR_TENANT_ID"
    )
    
    ollama = OllamaClient()
    
    emails = outlook.get_unread_emails()
    
    for email in emails:
        email_content = f"Тема: {email['subject']}\n\n{email['bodyPreview']}"
        
        # Классифицируем письмо
        classification_prompt = f"Классифицируй это письмо: {email_content}"
        category = ollama.generate(
            classification_prompt,
            system_prompt=OUTLOOK_SYSTEM_PROMPT
        )
        
        # Если это простой вопрос – генерируем ответ
        if "ВОПРОС_О_ДОСТАВКЕ" in category or "ВОПРОС_О_НАЛИЧИИ" in category:
            response_prompt = f"Напиши ответ на это письмо: {email_content}"
            reply = ollama.generate(
                response_prompt,
                system_prompt=OUTLOOK_SYSTEM_PROMPT
            )
            
            # Отправляем ответ
            success = outlook.send_reply(email["id"], reply)
            if success:
                print(f"Ответ отправлен на письмо: {email['subject']}")
        else:
            print(f"Письмо требует ручной обработки: {category}")
        
        time.sleep(2)  # Чтобы не превысить лимиты API

# Запускаем каждые 15 минут
import schedule

schedule.every(15).minutes.do(process_outlook_emails)

while True:
    schedule.run_pending()
    time.sleep(60)

Вот и все. Теперь каждые 15 минут система проверяет почту и отвечает на простые вопросы. Вы освободили себе 1-2 часа в день.

5 Автоматизируем Facebook Marketplace (это законно, если делать правильно)

Facebook не любит ботов, но любит быстрые ответы продавцов. Мы не спамим, а лишь ускоряем ответы на реальные вопросы.

Получаем access token для Facebook Graph API (нужна бизнес-страница, не личный профиль).

# facebook_client.py
import requests

class FacebookMarketplaceClient:
    def __init__(self, page_access_token, page_id):
        self.page_access_token = page_access_token
        self.page_id = page_id
        self.base_url = "https://graph.facebook.com/v18.0"
    
    def get_unread_conversations(self):
        """Получаем непрочитанные сообщения"""
        url = f"{self.base_url}/{self.page_id}/conversations"
        params = {
            "platform": "messenger",
            "fields": "messages{message,from,created_time},senders",
            "access_token": self.page_access_token
        }
        
        response = requests.get(url, params=params)
        data = response.json()
        
        conversations = []
        for conv in data.get("data", []):
            messages = conv.get("messages", {}).get("data", [])
            if messages:
                last_msg = messages[0]
                # Берем только сообщения от других пользователей
                if last_msg.get("from", {}).get("id") != self.page_id:
                    conversations.append({
                        "conversation_id": conv["id"],
                        "message": last_msg["message"],
                        "sender_id": last_msg["from"]["id"],
                        "timestamp": last_msg["created_time"]
                    })
        
        return conversations
    
    def send_message(self, recipient_id, message):
        """Отправляем ответное сообщение"""
        url = f"{self.base_url}/me/messages"
        params = {"access_token": self.page_access_token}
        payload = {
            "recipient": {"id": recipient_id},
            "message": {"text": message}
        }
        
        response = requests.post(url, params=params, json=payload)
        return response.status_code == 200

Интеграция с нейросетью:

def process_marketplace_messages():
    facebook = FacebookMarketplaceClient(
        page_access_token="YOUR_PAGE_TOKEN",
        page_id="YOUR_PAGE_ID"
    )
    
    ollama = OllamaClient()
    
    conversations = facebook.get_unread_conversations()
    
    for conv in conversations:
        # Определяем тип сообщения
        intent_prompt = f"Определи намерение в сообщении: {conv['message']}"
        intent = ollama.generate(
            intent_prompt,
            system_prompt=MARKETPLACE_SYSTEM_PROMPT
        )
        
        # Игнорируем спам
        if "СПАМ" in intent:
            continue
        
        # Генерируем ответ
        response_prompt = f"Напиши ответ на сообщение: {conv['message']}"
        reply = ollama.generate(
            response_prompt,
            system_prompt=MARKETPLACE_SYSTEM_PROMPT
        )
        
        # Отправляем
        success = facebook.send_message(conv["sender_id"], reply)
        if success:
            print(f"Ответ отправлен в диалог {conv['conversation_id']}")

Где все ломается: 5 ошибок, которые совершают 90% новичков

1. Температура 0.7 для бизнес-ответов. Получаете творческие, но бесполезные ответы. Для автоматизации ставьте 0.1-0.3.
2. Отсутствие system prompt. Без контекста нейросеть не знает, кто она и как должна отвечать. Это как нанять сотрудника без должностной инструкции.
3. Попытки обрабатывать все подряд. Нейросеть хороша для шаблонных вопросов. Сложные жалобы, переговоры о цене, юридические вопросы – оставляйте людям.
4. Игнорирование лимитов API. Outlook и Facebook имеют ограничения на количество запросов. Не делайте проверку каждую минуту.
5. Отказ от человеческого контроля. Всегда оставляйте возможность просмотреть ответы перед отправкой или настройте уведомления для определенных категорий писем.

А что если хочется больше автоматизации? Подключаем Auto-GPT

Наш текущий скрипт реагирует на события. Но что если нужно, чтобы нейросеть сама планировала действия? Например: "Раз в день проверяй статистику продаж на Marketplace и предлагай скидки на товары, которые давно висят".

Для этого берем Auto-GPT с поддержкой локальных моделей. Настраиваем его на работу с Ollama вместо OpenAI.

# .env для Auto-GPT
AI_SETTINGS_FILE=ai_settings.yaml
LLM_PROVIDER=ollama
OLLAMA_MODEL=llama3.2:7b
OLLAMA_BASE_URL=http://localhost:11434

Создаем задачу для Auto-GPT:

# task.yaml
- name: "Анализ Marketplace и автоматические скидки"
  goals:
    - "Получить список товаров на Marketplace, которые висят больше 14 дней"
    - "Проанализировать конкурентные цены на похожие товары"
    - "Предложить оптимальную скидку (5-15%)"
    - "Обновить цены на товары"
    - "Отправить уведомление о проделанной работе"
  constraints:
    - "Не снижать цену ниже себестоимости"
    - "Не делать больше 3 изменений цен в день"
    - "Всегда указывать в описании причину скидки"

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

Сколько это стоит и что нужно для запуска

• Оборудование: Ноутбук с 16GB RAM (для 7B модели) или ПК с видеокартой 8GB+ VRAM для большей скорости. Если нет – используйте более легкие модели в 3B параметров.
• Софт: Все бесплатно. Ollama, Python, библиотеки – open source.
• API: Microsoft Graph API – бесплатен для базовых операций. Facebook Graph API – бесплатен для управления страницей.
• Электричество: Нейросеть потребляет 50-100Вт в активном режиме. Это как лампочка.

Итого: ноль рублей на подписки. Разовые затраты на оборудование, которое у вас уже есть.

Что дальше? Куда развивать систему

Вы настроили базовую автоматизацию. Теперь можно:

1. Добавить перевод сообщений для международных клиентов
2. Интегрировать базу знаний компании (через локальные альтернативы NotebookLM)
3. Настроить автосоставление отчетов о переписке
4. Добавить анализ тональности сообщений (положительный/негативный/нейтральный)
5. Создать персонализированного помощника для каждого менеджера

Самое главное – вы больше не зависите от облачных сервисов. Ваши данные остаются у вас. Ваши процессы автоматизированы. И вы платите только за электричество, а не за каждый запрос.

Попробуйте начать с Outlook. Настройте ответы на вопросы о доставке. Увидите, как освобождается время. Потом добавьте Marketplace. Через месяц вы удивитесь, как раньше жили без этой системы.

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