BUILDING AI BUSINESS ASSISTANT / Complete Guide

A step-by-step tutorial on building your AI business assistant: Claude + MCPs + MongoDB. With detailed guidelines, prompts, templates, and configs.

In this guide I'll show you how to build an agentic business assistant that works for you 24/7, syncs your entire business context, and gets smarter over time.

Stack

• Claude Desktop

• Claude 4 [Opus/Sonnet]

• MongoDB + MCP

• Filesystem MCP

• GCal & Gmail integrations

• Obsidian / Zed [to view briefings]

• Wispr Flow / superwhisper [voice input]

• v0 + Vercel [dashboard → optional]

Why I Built This Assistant

It’s time to admit it: traditional productivity software is broken.

It forces you to:

• Copy-paste things between different apps

• Work as a data entry clerk

• Constantly keep in mind dependencies

It’s just exhausting!

Automations and AI workflows helped a bit.
But the main problem remains: they hold only limited context.
[not seeing the full picture of your business].

They can sync data, but they don't know WHAT matters & WHY.

So I built an agent that holds the FULL CONTEXT of my business:

• My goals and priorities

• Tasks, projects, clients

• Structure and dependencies

• Current state of affairs

Now I can simply dictate:

“Meeting with Sam done - he approved the project, wants to start in July. Update proposal status. BTW add 2 new subscriptions to tracker, and prepare full briefing on tomorrow's priorities”

Assistant breaks it down, syncs everything, and gives me an updated briefing.

I use it to:

• Stay on top of tasks & projects

• Track my CRM & opportunities

• Better manage my schedule

• Automate my finances

Extensive knowledge helps it to be very smart, contextual and precise.

The agent-first productivity is here!

If you're still alt-tabbing between 5 apps & wasting time on data entry ... ngmi

But no worries you are not late to the party.
All this became a reality just a few months ago:
with new generation of models [o3, Gemini 2.5 PRO, Claude 4] & updated MCP.

So let me show you how to build the assistant like that.
I broke the whole process into 7 steps.

STEPS

1️⃣ Set up MongoDB free instance [10 minutes]
2️⃣ Connect MCP servers to Claude Desktop [10 minutes]
3️⃣ Create your data schema [20 minutes]
4️⃣ Set up Claude project [30 minutes]
5️⃣ Set up other integrations (GCal, Gmail) [5 minutes]
6️⃣ Create daily briefings / dashboard [20 minutes]
7️⃣ Give it a spin!

Let's go step by step. I'll provide you with detailed guidelines, prompts, templates, and configs.

1️⃣ Set up MongoDB free instance

I use MongoDB as a memory for the agent and single source of truth for everything that is happening in my business.

Why MongoDB?

Mongo is super flexible. Way more flexible than traditional SQL databases.
SQL forces everything into rigid tables with predefined columns. MongoDB stores "documents" → flexible containers that hold whatever information you need.

Need to add a new field? Just add it. No restructuring required.

This flexibility is perfect for AI assistants.

Let’s set it up!

STEPS

[1] Create Your Account

• Go to mongodb.com/atlas

• Sign up with Google or email

[2] Create your free cluster

• After signing in, click Create cluster

• Choose the FREE tier

• Pick your cloud provider [AWS is fine]

• Choose the region closest to you

• Name your cluster something simple like "business-assistant"

• Click Create Deployment

[3] Get your connection string

After your cluster deploys (takes 1-3 minutes), MongoDB will provide a connection string. It’s gonna look something like this:

mongodb+srv://claude-assistant:<password>@cluster0.xxxxx.mongodb.net/?retryWrites=true

This is the only thing you need to connect MongoDB to Claude via MCP.
Save it → we'll use it on the next step.

2️⃣ Connect MCP servers to Claude Desktop

What is MCP?

Model Context Protocol (MCP) is an open protocol that standardizes how LLMs/Agents interact with apps / tools / data sources.

It's essentially a smart API that:

• Provides the connection protocol

• Contains instructions for the agent on how to use this protocol

With MCP Claude can skilfully use many tools.
To set up MCPs you need to install Claude Desktop.
And you need to have Pro or Max subscription.

Important constraint: MongoDB MCP doesn't work on mobile (MCP servers run on your local computer). That's going to change: the wave of cloud MCP is coming. Soon you will be able to access tools through MCP on mobile too.

STEPS

[0] Set up your first MCP server

If you've never used MCP → start with the Filesystem MCP [we'll need it later anyway]. This MCP allows Claude to read/write files on your local computer in specific folders.

Here is the official guide on how to set it up.

When you are done → test it with a prompt:

Create a text file with “Hello world” inside

Check if the file was successfully created.

Perfect ☑️

[1] Set up MongoDB MCP

Now let's connect MongoDB MCP.

Add this part to your Claude Desktop config:

{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": [
        "-y",
        "mongodb-mcp-server",
        "--connectionString",
        "mongodb://localhost:27017/myDatabase"
      ]
    }
  }
}

Change connection string to the one we got on the first step.
Your config will look like this:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    },
    "MongoDB": {
      "command": "npx",
      "args": [
        "-y",
        "mongodb-mcp-server",
        "--connectionString",
        "mongodb+srv://claude-assistant:<password>@cluster0.xxxxx.mongodb.net/"
      ]
    }
  }
}

[2] DOUBLECHECK👀

It should have:

• Real username for filesystem

• Your connection string for MongoDB

• Config file formatted correctly (ask Claude or other LLM to verify it if you are not sure)

Now your Claude is connected to MongoDB MCP and ready to access your database ☑️

Time to put some stuff in there!

3️⃣ Create your data schema

In MongoDB data is stored in JSON-like format.

Claude will help you to create a collection for each data type. Most basic ones:

• tasks

• projects

• people

• opportunities

• expenses

Think of a collection as a table in traditional database.

STEPS

[1] Define the basic data structure for each collection

This is where MongoDB's power shines: you don't have to make it rigid and follow it for every item.
New entries can miss fields or introduce new fields.

Example: projects collection

[
  {
    "_id": "wonka_consumer_research_2025",
    "name": "Wonka Consumer Research Project",
    "description": "Research for Wonka Industries new product line",
    "status": "active",
    "client": "Wonka Industries",
    "budget": 25000,
    "currency": "USD"
  },
  {
    "_id": "finance",
    "name": "Finance & Administration",
    "description": "Expense reporting & budget tracking",
    "status": "ongoing"
  }
]

Notice how these two entries share some fields but not others.
But all of them have unique IDs (slugs). We will use them to make connections.
BTW you do not have to input them yourself → Claude will do it for you.

[2] Connect collections

Now here's how you connect tasks with projects using ID (slug):

[
  {
    "_id": "reply_client_email_sarah_timeline",
    "title": "Reply to Sarah's email about project timeline",
    "projectId": "wonka_consumer_research_2025",
    "priority": "MEDIUM",
    "deadline": "2025-06-28",
    "status": "todo"
  },
  {
    "_id": "submit_expense_report_may_2025",
    "title": "Submit May expense report",
    "projectId": "finance",
    "priority": "HIGH",
    "deadline": "2025-06-30",
    "notes": "Include receipts from client lunch and conference travel",
    "status": "done"
  }
]

In tasks collection you need to have projectId field.

[3] Customize structures

Add relevant fields. Think about what fields might be unique to your business / your personal style.

For example:

invoiceTerms, dependencies, stakeholders, recurrence

Ask Claude to help you to design your schema.
When satisfied → move to the next step.

[4] Customize structures

Make sure you have MongoDB MCP connected:

Ask Claude to create the collections with your real data.

Use these prompts:

Create MongoDB collection 'projects' and add data: 
<paste your projects in structured format>

Create collection 'tasks', connect to relevant projects via projectId. data:
<paste your tasks in structured format>

Important: use Opus 4 / Sonnet 4 Models with Extended Thinking enabled.

Once you have real data in MongoDB, it's time to set up the agent.
We will use Claude Project for that.

4️⃣ Set up your Claude Project

Claude is not just a chatbot. It has agentic abilities:
it can make decisions, use tools and take actions.

You can think of Claude Project as agent template. It allows you to define a consistent identity & instructions with a system prompt. Plus add specific knowledge to your agent.

Steps

[1] Create your project

• Give it a name and description

• Project becomes your dedicated workspace

[2] Add your system prompt

The system prompt defines your agent's identity and how it should use tools.

Balance is key here:

• If prompt is too strict → it will limit autonomous thinking

• If prompt is too vague → agent’s behaviour will be inconsistent and misaligned

Here's a template you can start with:

<!-- Template Usage: Replace {{placeholder}} with your specific information. Comments provide examples and guidance. -->
ROLE: Business and work management assistant

## Coordinate Work  
Manage my workflow utilizing these native entities:  
**tasks** [work tasks] the atomic, actionable step  
**projects** – projects, products, or ongoing responsibilities
**{{YOUR_OTHER_ENTITIES}}**
<!-- Examples: goals, habits, expenses, etc. -->

IMPORTANT: Resources are stored in MongoDB in {{DATABASE_NAME}} database in collections:
<!-- Replace DATABASE_NAME with your actual one, for example: business-assistant -->
tasks, contacts, projects, {{YOUR_OTHER_COLLECTIONS}}

Day-to-day briefings stored in local files in this format:
work-briefing-<DATE>.md
Briefings act as daily todo lists.
The updated form should be reflected in MongoDB

MongoDB - single source of truth
Local briefing files - fleeting todos
use reference.md as an inspiration structure for daily briefings

## Calendar
You have access to my Google Calendar
Consider it when relevant

## Relationship Management  
Track contacts, opportunities, and relationships for:  
**Professional Network**  
**Client Relations**
**Personal Connections**
**{{YOUR_RELATIONSHIP_CATEGORIES}}**
<!-- Examples: Industry contacts, mentors, collaborators, vendors, etc. -->

## Content & Communication  
Plan, schedule, and repurpose material across:  
**X/Twitter**
**Newsletter**
**{{YOUR_CONTENT_PLATFORMS}}**

## {{YOUR_OTHER_AREAS_AND_TOOLS}}
<!-- Example areas: personal growth, finance, etc. -->
<!-- Example tools: email, GoogleDrive, Notion, etc. -->

---
# HOW

# How to Assist
**Ingest & Organize** – Extract items and translate them into the correct entities (Task, Project, Contact and so on).  
**Surface What Matters** – Proactively highlight high-impact Projects, important contacts, and upcoming deadlines.  
**Suggest Next Actions** –Try to recommend concrete, appropriately sized Tasks.  
**Keep Everything Linked** – Ensure each contact, project, task and other items have references / are referenced (where relevant).  
**Maintain Momentum** – Offer clear priorities, checklists, and lightweight dashboards while respecting the preferred structure above.

## Communication Style
Be concise but actionable.  
Use plain language; avoid jargon unless it's already in use.  
Ask clarifying questions only when information is missing or ambiguous.

## VALUE
Remember: Your value lies in turning scattered items, notes, ideas, and opportunities into an integrated engine that advances the business, delights clients, and ships content consistently.

Adjust it to match your business needs & structure.

[3] Add business knowledge

Don't try to put everything into the system prompt.
Instead, add specific knowledge to the project context → Claude uses RAG (Retrieval Augmented Generation) to access it efficiently.

Examples of what to add:

• Service offerings

• Client and partnership information

• Operating procedures

• Pricing structures

• Team roles and responsibilities

• Hiring practices

Boom! Now your agent is operational ☑️

Important: to work with the business assistant → always start new chats WITHIN your project. This ensures Claude uses the system prompt and access to knowledge.

5️⃣ Set up additional Integrations/tools

Let’s integrate some useful tools.

STEPS

[1] Integrate calendar & email

Connect Claude to your Gmail & Google Calendar natively using integrations available in Claude Desktop: simply click Connect and authenticate Claude using your Google account.

To connect Claude to different providers like Outlook or Microsoft 365 → use MCP.

IMPORTANT: Some MCP servers are made by independent developers and might not be secure. Always check who made the MCP service you're using and whether you can trust this provider.

[2] Add voice input

At the moment, Claude Desktop doesn't have native voice input.
So you need a tool for that.

I use Wispr Flow [Mac]. It's the fastest and most accurate Speech → Text translator I know.

superwhisper would be another good option.

Now Claude has access to more contexts and you can talk to it ☑️

6️⃣ Create daily briefings / dashboards

Your assistant is fully operational and you can interact with it via chat interface.

But it’s not always optimal.

Sometimes you still want to have GUI (Graphical User Interface) to interact:
dashboard, to-do list, kanban. Something familiar for contextual input / adjustments.

Here is how you can do it:

Option 1: Markdown daily briefings [EASY]

The simplest approach is to use markdown:
Fleeting documents that provide a snapshot of your business on a given day.

Here's an example (in Obsidian):

It’s well structured and you can use mermaid diagrams.

To set this up:

[1] Add formatting rules to your system prompt

## USE these work-briefing formatting rules

Optimization
- **NO** backticks for emphasis
- **NO** HTML tags
- **USE** bold text for important items
- **USE** Mermaid diagrams: `pie`, `timeline`, `quadrantChart`

Callout Strategy
- **Only 4-5 callouts** per document
- **Position:** Next to headers, NOT containing content
- **Purpose:** Navigation and context only

```markdown
> [!danger] Impact Alert
> Context about risks, not the tasks themselves
```

Key Principles
1. **Tables:** Use markdown tables for structured data
2. **Checkboxes:** `- [ ]` for all actionable items
3. **Emphasis:** Bold text, not backticks
4. **Visual bars:** Use █ and ░ for progress
5. **Sections:** Clear with `---` dividers

Remember
- Callouts = Context providers, not containers
- Mermaid = Visual intelligence
- Tables = Structured data
- Bold = Important text
- Emojis = Quick scanning

use briefing template: briefing_template.md

[2] Upload briefing template to Claude Project

[3] Use the Filesystem MCP to write daily briefings directly to your system.

Prompt:

Create a full daily briefing for me <current date>

[4] Use Obsidian / Zed / Cursor or any other MD editor to view briefings and make changes.

Important: When you manually edit a briefing, tell Claude explicitly:

I've updated the briefing, please sync these changes to MongoDB

Option 2: MongoDB Compass [MEDIUM]

MongoDB has a visual client: Compass.

You can view / query / filter / edit your data using a relatively simple UI.

Option 3: Web-app dashboard [ADVANCED]

The more advanced approach:
building a proper dashboard on top of MongoDB.

It can be fully customized to show your tasks, projects and other items in a structured, familiar interface.

v0. Dashboard prototype

I use v0 + Vercel + MongoDB for this.

v0 can easily generate dashboard prototype for you. Yet syncing it with MongoDB requires some coding/deployment skills.

It’s gonna be a bit too much for this guide.
If you're interested in the full tutorial, drop me a comment and I'll create a dedicated guide.

And there you have it! We’re all set ☑️

7️⃣ Give it a spin!

Your system is fully operational. Time to test it!

Try these prompts:

Give me today's briefing

What are my most important opportunities?

Show me all upcoming deadlines

Which clients haven't I contacted in 30+ days? 
Create a contact strategy to reach them

Create an action plan for next week's priorities

Add task X and make it priority for today

Watch as Claude:

• breaks down requests into granular items

• connects the dots between scattered emails, meetings & tasks

• analyzes your business situation 360°

• creates contextual artefacts & strategies

• evaluates opportunities and risks

This is your new business powerhouse ☑️

Wrapping Up

For me this build was life-changing!

Instead of being a data clerk for clunky productivity tools, I now just talk to Claude.
It handles the tedious stuff while surfacing patterns & opportunities I was too busy to see.

With memory features coming soon, it'll get even smarter: remembering our interactions and considering them every time we speak [additional layer of memory to MongoDB]

Not everything will be smooth of course.
Expect some rough edges:

• Your first version won't be perfect

• MCPs occasionally glitch

• Claude might confuse tools (for example: create files when you want chat responses → just say "return in chat, don't create a file"

• You still need to do some manual input and clean-up

  [for example: deleting out-of-date briefings to avoid context poisoning]

You'll hit some paper cuts & bugs for sure.

But it should not stop you! Spend time with your agent. Tweak the system prompt. Update the knowledge base. Give it feedback.

Within a month of daily use, it'll be aligned with you almost perfectly.
And with new models & MCP updates, your assistant will keep getting better.

You're not just building a tool.
You're building a partner that evolves with you, making you more productive and less overwhelmed every single day.