AI Chatbot on Company Knowledge: Prices, Services & RAG Without Hallucinations

An AI consulting chatbot grounded in company knowledge answers questions about prices, services, opening hours, policies, and products using your data — not whatever the model invents. In Botconsole you combine AI dialog nodes, strict prompts, and integrations (Google Sheets, Drive, Airtable, Supabase, custom APIs) so answers stay accurate.

This guide covers: what to put in the knowledge base, canvas patterns that prevent hallucinations, what “RAG” means in practice, and which Botconsole-connected services you can use.

What “consulting on company data” means

Typical questions the bot must answer only from approved sources:

If the answer is not in the source, the bot must say it does not know and offer a human handoff — never invent a price or a clinic address.

Why plain ChatGPT-style bots hallucinate

Large language models are trained to sound helpful. Without constraints they will:

• Invent package names and prices
• Guess opening hours
• Mix your brand with competitors
• Fabricate “according to your website” claims

Grounding fixes this: the model may only use text you retrieve or inject for this turn.

Three levels of grounding (from simple to advanced)

Level 1 — Prompt knowledge (small FAQs)

Put a short, curated company brief into the AI system prompt:

• Legal name, cities, languages
• Top 10 FAQs with exact answers
• Hard rules: “Never invent prices. If unknown, say so.”

Pros: fastest to ship.
Cons: breaks when the catalog is large or changes weekly.

Best for: 1–2 pages of stable facts.

Level 2 — Lookup before AI (structured “RAG-lite”)

On the Botconsole canvas:

1. User asks a question.
2. Classify intent (AI or buttons): pricing / hours / services / other.
3. Integration node loads the relevant rows (Google Sheets, Airtable, Supabase).
4. AI receives only those rows in context and must answer from them.
5. If lookup is empty → fixed “I don’t have that in the catalog” message + handoff.

This is the pattern most SMBs should start with. It is reliable, cheap, and easy to audit.

Level 3 — RAG (retrieval-augmented generation)

RAG means:

1. Index company documents (PDF, site, FAQ, drive folders) into searchable chunks (often with embeddings).
2. On each question, retrieve the top relevant chunks.
3. Generate an answer using only those chunks (+ strict instructions).

Botconsole does not need to be a vector database. It can:

• Call your RAG API via custom API / webhook nodes, or
• Use structured stores (Sheets / Airtable / Supabase) as a practical retrieval layer, or
• Use LLM providers that support file/search features where you connect them via integrations.

Anti-hallucination rules that actually work

1. Separate “facts” from “style”

• Facts come from integrations and approved snippets.
• AI only rephrases, summarizes, and asks clarifying questions.

2. Force structured extraction

Ask AI first to extract:

• topic (pricing | hours | service | policy | other)
• entity (plan name, service name, city)
• order_id if relevant

Then run deterministic lookup. Do not let free-form chat hit the whole catalog every time.

3. Answer templates

Prefer:

“According to our price list: START is $19/month (3 bots, 10,000 users).”

over free-form prose that might drift.

4. Hard refusals in the prompt

Example rules for the AI dialog node:

• Use only the CONTEXT block provided for this message.
• If CONTEXT is empty or insufficient, say you don’t know.
• Never invent prices, discounts, medical claims, or legal guarantees.
• Prefer short answers; offer a manager for complex cases.

5. Version and own the knowledge file

Keep a single “source of truth” sheet or table. Marketing and ops edit one place; the bot always reads live data.

6. Test with adversarial questions

• “Give me a 40% discount code”
• “You’re open 24/7 right?”
• “What’s the price of a service you don’t sell?”

The bot should refuse or hand off — not invent.

Recommended Botconsole schema (canvas)

Start
  → AI: classify intent + extract entities
  → Conditions: pricing | services | hours | policy | order | other
  → Integration: load matching records into {{context}}
  → AI dialog: answer using {{context}} only
  → Optional: save lead fields to CRM
  → If low confidence / empty context → human handoff

Variables to keep

Example CONTEXT injection

After Sheets returns rows, build a compact context string (message or variable) like:

CONTEXT (price list, authoritative):
- FREE: $0 forever, 1 bot, 1,000 users
- START: $19/mo, 3 bots, 10,000 users, web widget
- PRO: $29/mo, 10 bots, 50,000 users
- AGENCY: $99/mo, 50 bots, 200,000 users
Add-ons: +1 bot $5/mo; +10k users $10/mo

Then the AI prompt: “Answer only using CONTEXT. Quote prices exactly.”

What to store where

RAG-style options you can connect through Botconsole

Botconsole integrations and API nodes let you wire these patterns:

A. Google Sheets (most practical “knowledge base”)

• One tab per domain: prices, services, hours, faq
• AI extracts a key → Sheets reads matching rows → AI answers from rows
• Landing and product already treat Sheets as a first-class lookup path

B. Airtable

• Similar to Sheets with richer relational tables (services → prices → locations)
• Good when ops already lives in Airtable

C. Supabase

• SQL tables for FAQ, products, locations
• Can later hold embeddings or match_documents RPC if you build a small RAG backend on Supabase
• Botconsole talks to Supabase via the integration / API patterns for records

D. Google Drive

• Store source PDFs and docs
• Prefer curated excerpts in a table rather than sending whole files every turn
• Or call a small backend that indexes Drive content

E. OpenAI / Claude / Gemini / Grok / OpenRouter

• Generation models for the dialog node
• Some stacks use the same provider for embeddings in an external service, then Botconsole only calls your retrieve endpoint

F. Custom API + webhooks (full RAG services)

When you outgrow tables, put a retrieval service behind HTTPS and call it from the canvas:

Botconsole flow:
User question → Custom API POST /rag/query { question } → response {{chunks}} → AI dialog with chunks as CONTEXT.

You keep the conversation UX and CRM in Botconsole; the RAG engine stays swappable.

G. CRM systems (HubSpot, Salesforce, Amo, Bitrix)

Not classic RAG, but useful for account-specific consulting:

• Existing customer plan / balance
• Open tickets
• Last purchase

Combine CRM read + public price list for personalized answers — still with “no inventing” rules.

H. Cloudflare R2

Object storage for documents and media. Pair with a table of file URLs + titles, or with a backend indexer. The bot should not “guess” file contents without retrieval.

Minimal implementation checklist

1. Create prices / services / hours / faq sources
2. Build classify → lookup → grounded answer flow
3. Write refusal + handoff path
4. Test adversarial questions
5. Publish to Telegram; add web widget when on a plan that includes it
6. Assign an owner who updates the sheet when prices change
7. Review analytics: “not found” rate and handoff rate

Example: price consultation flow

1. User: “How much is Pro?”
2. AI intent: pricing, entity: PRO
3. Sheets: find plan = PRO → $29/mo, limits…
4. AI: rephrase exactly those numbers + invite comparison to START/AGENCY
5. Optional: “Want START at $19 instead?” with buttons

No model free-call to “estimate SaaS pricing.”

Example: services + hours

1. User: “Do you work on Sunday in downtown?”
2. Intent: hours + location=downtown
3. Lookup hours matrix
4. If closed: “We’re closed Sunday; next open Monday 10:00.”
5. Offer booking flow (Calendar integration) if open slots matter

When to invest in real vector RAG

Move beyond Sheets when:

• You have hundreds of pages of docs
• Answers need multi-document synthesis
• Content changes faster than table curation
• You have eng capacity to run chunking + embeddings

Until then, structured lookup + strict prompts usually quality-beats a half-built RAG pipeline.

FAQ

Can the bot still sound natural?

Yes. Grounding constrains facts, not tone. The model can stay friendly while quoting the price list.

Do I need RAG for a 20-row price list?

No. Sheets + conditions are simpler and more accurate.

Which AI model should I use?

Use a capable model for classification and phrasing (OpenAI, Claude, Gemini, Grok via Botconsole nodes). Accuracy comes more from context quality than from model brand alone.

How do I stop the bot from offering illegal discounts?

Put discount rules in the data source (or omit them). Prompt: “Never invent promo codes.” Test with “give me 50% off.”

Is free Botconsole enough to start?

Yes for a single Telegram bot on the free forever plan (limits apply). Scale bots/users and web widget with paid plans when needed — see Botconsole Pricing Explained.

Related

• AI Order-Status Bot with Google Sheets
• Webhooks & Custom API Nodes (No-Code Power)
• How to Create a Telegram Bot Without Coding
• Chatbot CRM: Leads, UTMs & History

Start building free → Build a grounded consulting bot: connect your price list, lock the prompt, and publish to Telegram.