Developing a Bot for Answering Questions on Marketplaces

Developing a Bot for Answering Questions on Marketplaces

Every day sellers on Ozon, Wildberries, and Yandex.Market receive dozens of identical questions: availability, size, delivery times. Manually answering each takes 2-3 minutes, and 50 questions consume 2 hours. Missing a question or answering incorrectly reduces buyer trust. Automation removes this burden and lets managers focus on complex requests. We develop bots with LLM processing that answer standard questions in seconds and escalate non-standard ones to a manager. This cuts response time from 4 hours to 30 seconds and boosts conversion by 15-20%.

Why Automating Questions Pays Off

The hours spent on repetitive answers can be redirected to product development and marketing. The bot works 24/7 without breaks or vacations—every missed question may lose a sale. Customers who receive quick answers are more likely to place orders and return.

Architecture of Question Processing

The bot polls the marketplace API every 60 seconds or receives webhook notifications. For each question, classification runs: it's compared against a template database via cosine similarity of embeddings. If similarity is above 0.9, a prepackaged answer is sent. If lower, the LLM takes over.

We use gpt-4o-mini or similar models with temperature 0.3 to generate answers based on the seller's knowledge base. For more details, see OpenAI API. An additional LLM call evaluates confidence: if below 0.85, the question is escalated to a Telegram chat for the manager.

Fetching Questions via Marketplace API

# Ozon Seller API — получение новых вопросов
import httpx

class OzonQAClient:
    def __init__(self, client_id: str, api_key: str):
        self.headers = {
            'Client-Id': client_id,
            'Api-Key':   api_key,
        }

    def get_unanswered_questions(self) -> list:
        resp = httpx.post(
            'https://api-seller.ozon.ru/v1/qa/list',
            headers=self.headers,
            json={'status': 'without_answer', 'page_size': 50}
        )
        return resp.json().get('result', {}).get('questions', [])

    def reply(self, question_id: str, answer_text: str) -> bool:
        resp = httpx.post(
            'https://api-seller.ozon.ru/v1/qa/answer/seller',
            headers=self.headers,
            json={'question_id': question_id, 'text': answer_text}
        )
        return resp.status_code == 200

Why LLM Is Better Than Templates Alone

LLM handles questions absent from the database and formulates answers in natural language, maintaining a consistent tone of voice.

Classification and Answer Generation

from openai import OpenAI

client = OpenAI()

FAQ_CONTEXT = """
Вы — помощник продавца на маркетплейсе. База знаний:
- Доставка: 3-7 дней по России, СДЭК или Почта России
- Гарантия: 12 месяцев на все товары
- Возврат: в течение 14 дней
- Оплата: картой, СБП, наличными при получении
"""

def generate_answer(question: str, product_info: dict) -> dict:
    system_prompt = FAQ_CONTEXT + f"\n\nТовар: {product_info['name']}\n{product_info['description']}"

    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': system_prompt},
            {'role': 'user',   'content': question},
        ],
        temperature=0.3,
    )

    answer = response.choices[0].message.content

    # Определяем уверенность через отдельный запрос
    confidence = classify_confidence(question, answer)

    return {
        'answer':     answer,
        'confidence': confidence,   # 0.0 — 1.0
        'auto_send':  confidence >= 0.85
    }

Escalation to a Manager

Questions with low confidence are forwarded for review:

if not result['auto_send']:
    # Отправляем менеджеру в Telegram с кнопками
    await telegram.send_message(
        chat_id=MANAGER_CHAT,
        text=f"❓ Вопрос по товару \"{product['name']}\"\n\n"
             f"Вопрос: {question}\n\n"
             f"Предлагаемый ответ:\n{result['answer']}",
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("✅ Отправить", callback_data=f"approve:{question_id}"),
            InlineKeyboardButton("✏️ Изменить", callback_data=f"edit:{question_id}"),
        ]])
    )

Step-by-Step Bot Setup

1. Integration with marketplace API — we connect to Ozon Seller API or Wildberries API.
2. Upload knowledge base — you provide typical questions and answers, we configure embeddings.
3. Choose LLM model — typically gpt-4o-mini or claude-3-haiku, optimal for price and quality.
4. Set confidence thresholds — you decide the probability at which the bot auto-answers vs. escalates.
5. Deploy on a server or cloud function — using Docker or serverless.
6. After deployment, load testing ensures stability.

What’s Included in the Work

• Development and integration of a question collection module via marketplace API.
• Configuration of the classifier and LLM generation with your knowledge base.
• Implementation of Telegram escalation with approve/edit buttons.
• Architecture documentation and operation manual.
• Handover of server access, API keys, and source code.
• Team training: updating templates, changing thresholds, adding new managers.
• Technical support for one month after launch.
• Monitoring and alert setup for failures.

What Else This Approach Provides

Beyond automation, the bot collects question statistics, identifies common product issues, and helps improve product cards. For example, if 10% of questions are about size, add a size chart.

Platform Comparison by API Capabilities

Platform choice affects integration complexity; for instance, Wildberries does not support image replies, which limits options.

Timelines

A basic version for one marketplace with Telegram escalation: 5–8 business days. If multiple marketplaces, complex logic, or CRM integration is needed, the timeline may extend to 14–20 days.

How to Start?

We’ll evaluate your project for free — contact us. We’ll clarify which marketplaces you use, question volume, and knowledge base requirements. The solution is delivered turnkey: from analysis to launch and team training.

Our team has over 5 years of experience in marketplace integrations and LLM. We guarantee the bot will automatically handle at least 80% of questions. Get an engineer’s consultation for your project.

Marketplace API (polling / webhook)
    ↓
Question Classifier
    ↙             ↘
Template Answer   LLM Generation
(FAQ base)        (OpenAI / Claude)
    ↓                    ↓
Auto-Reply          Manager Review
    ↓
Marketplace API → Send Answer

AI Integration: Chatbots, RAG, Semantic Search, Recommendations

In 8 out of 10 projects, an "AI chatbot" turns out to be an expensive wrapper over GPT-4o with a system prompt. Without access to real company data. The user asks "how much does the Premium plan cost?" — the bot hallucinates a price out of thin air. Asks "when will my order arrive?" — gets a polite "contact support." This is not integration — it's imitation. We have implemented RAG solutions in 30+ projects over 5 years: from e-commerce stores to medical portals. We guarantee: useful AI assistance begins where the model reads your documents, not generic answers.

How do we build RAG systems?

Retrieval-Augmented Generation — standard architecture: query → find relevant fragments in a vector DB → insert found context → model response. But the devil is in the implementation details. Let's break down key components that determine quality.

Chunking. Cutting a document into 500-token pieces without regard for structure is a guarantee of losing meaning. If the cut lands in the middle of a paragraph, context breaks. Solution — recursive RecursiveCharacterTextSplitter with 10–15% overlap for documentation. For contracts and instructions, we use a semantic splitter: extract headings, lists, code blocks — each section becomes an independent chunk. Difference in search quality: on a medical project, precision increased from 0.55 to 0.84 just by proper chunking.

Embedding model. For Russian-language texts, intfloat/multilingual-e5-large gives a noticeable accuracy boost over outdated text-embedding-ada-002. In our measurements, NDCG@10 on a test set of 10,000 query-document pairs is 12% higher. OpenAI text-embedding-3-large is good for English content, but for Russian we recommend BAAI/bge-m3 or the mentioned e5-large.

Vector DB. If you already have PostgreSQL — pgvector saves resources. Install extension CREATE EXTENSION vector, add column vector(1024), create HNSW index. On a project with 80,000 support articles, p95 search time was 12 ms. That's enough. For catalogs with millions of items — Qdrant or Weaviate: native hybrid search and sharding out of the box.

What does hybrid search give?

Vector-only search is blind to exact matches: SKUs like "ABC-123", proper names, abbreviations are lost. Full-text-only search doesn't catch synonyms and paraphrasing. Combining via RRF (Reciprocal Rank Fusion) gives the best of both worlds: BM25 + vector search, results merged. In practice, recall@20 increases from 0.65 to 0.92 — the difference is noticeable to the user.

Reranking — final filter: top-20 candidates from hybrid search are run through a cross-encoder cross-encoder/ms-marco-MiniLM-L-6-v2. It adds 50–100 ms to response time, but relevance improves by another 5–10%. Without reranking, the chatbot may show irrelevant documents.

How to implement semantic search on a site?

A search for "comfortable leather armchairs" should find products described as "soft chairs made of natural leather" — ordinary LIKE search cannot do this. Our architecture: when adding a product/post, automatically generate an embedding via multilingual-e5-large, store it in pgvector. On query, embed it with the same model, search nearest neighbors via cosine distance with HNSW index. For a catalog of 100,000 items, index builds in 3 minutes, memory ~400 MB (1536-dimensional vectors). Average search time: 20 ms.

What about recommendation systems?

Collaborative filtering ("users like you bought X") requires history — at least 2–3 months of data with 1000+ active users. For startups or small projects, we use content-based: embedding of current product → search nearest neighbors by cosine similarity. When enough statistics accumulate (usually 15–20 interactions per user), we switch to a hybrid LightFM model. It combines behavior and product features. In our e-commerce project with 50,000 SKUs, the hybrid model increased conversion in the recommendation block by 18% (A/B test lasted 2 weeks).

How does streaming work?

Users shouldn't wait for the entire text to be generated — it kills UX. Server-Sent Events (SSE) is the protocol for token streaming. OpenAI SDK supports stream: true, returning an AsyncIterator. On frontend — Vercel AI SDK (useChat) or custom EventSource. Typical mistake: using WebSocket for unidirectional streaming — SSE is simpler (less code, built-in reconnect). Stack: Node.js + SSE + React.

How to orchestrate agents?

A simple chatbot answers. An agent performs actions: creates a Jira ticket, checks order status in CRM, books a calendar slot. For orchestration, we use LangGraph: state graph where each node is a model or tool call. Vercel AI SDK useChat + tools for Next.js allows adding integration in 10 lines of code. Main challenge — reliability: the model sometimes calls the wrong tool or passes malformed parameters. Protection — Zod schemas for each tool and structured outputs to guarantee JSON.

What does the work include?

Additionally: we hand over vectorizer source code, monitoring dashboards (Langfuse), admin panel access for knowledge base updates. Post-production support — 1 month free.

What are the timelines?

Pricing is calculated individually after project discovery. We'll evaluate your project in 1 day. Contact us — we'll show how to turn AI from a toy into a profit-driving tool.