Task Assistant

This is Krishna's first end-to-end AI project. It combines:

1. A Task Manager — simple to-do list (add, list, complete tasks)
2. An MCP Server — exposes the task manager as "tools" that an AI can use
3. A FastAPI backend — turns everything into a real web service
4. (Next step) A RAG layer — lets the assistant also answer questions from documents
5. (Later step) Docker + AWS deployment — makes it a real, hosted app

Why this project matters

Most beginner AI projects are just a script in a notebook. This one is built the way real companies build things: as a service other programs (or an AI) can actually use.

Folder structure

mcp-task-assistant/
├── app/
│   ├── tasks_store.py    # the "database" (in-memory for now)
│   ├── mcp_server.py     # exposes tasks as MCP tools
│   └── main.py           # FastAPI web app
├── requirements.txt
└── README.md

How to run this on your own laptop

Step 1 — Install Python

Make sure you have Python 3.10 or newer. Check with:

python --version

Step 2 — Create a virtual environment

This keeps this project's packages separate from everything else on your computer.

python -m venv venv

Activate it:

• Windows: venv\Scripts\activate
• Mac/Linux: source venv/bin/activate

Step 3 — Install the required packages

pip install -r requirements.txt

Step 4 — Run the MCP server (this is the "tools" part)

python app/mcp_server.py

This starts a server that exposes 3 tools: add_task, list_tasks, complete_task.

Step 5 — Run the FastAPI app (this is the "web service" part)

In a second terminal (with venv activated again):

uvicorn app.main:app --reload

Then open http://127.0.0.1:8000/docs in your browser — you'll see a live, clickable page where you can test adding and listing tasks.

Step 6 — Talk to the AI agent (Groq API — free tier)

Now that create_task / get_tasks / finish_task exist as MCP tools, we can let an actual AI decide when to use them, instead of you calling them by hand. We're using the Groq API — cloud-hosted, fast, and has a generous free tier. If you already have a Groq API key from an earlier project, you can reuse it — a key belongs to your account, not to one specific app.

1. Get / find your Groq API key

Go to https://console.groq.com/keys — reuse your existing key or create a new one.

2. Set up your key

Copy .env.example to a new file named .env, and paste your real key in:

GROQ_API_KEY=your-real-key-here

3. Install the packages

pip install -r requirements.txt

4. Run the agent

python app/agent.py

You do NOT need to separately start mcp_server.py this time — the agent starts it automatically in the background.

5. Try it out

Type things like:

add a task to finish my resume
add a task to practice interview questions
show me all my tasks
mark task 1 as done

Watch the terminal — you'll see a line like [Agent is calling tool: create_task ...] right before it responds. That line is proof the AI is actually deciding to use your tool, not just chatting.

Step 7 — Add document search (RAG)

Now your assistant can also answer questions using your own documents, not just manage tasks.

1. Install the new package

pip install -r requirements.txt

(This installs chromadb, our free local search database. It also downloads a small model the first time you use it, to understand text meaning — after that first download, it works offline.)

2. Add your documents

Put any .txt files into the documents/ folder. A sample file (company_leave_policy.txt) is already there so you can test right away.

3. Build the search index

Run this every time you add or change a document:

python app/build_index.py

4. Ask questions

Run the agent as usual:

python app/agent.py

Try asking:

how many paid leave days do employees get?
what happens to unused leave at the end of the year?

You should see [Agent is calling tool: search_documents ...] before it answers — that means it actually looked in your document instead of guessing.

Step 8 — Package with Docker

Docker packages your whole app — code, packages, everything — into one "box" (called an image) that runs the exact same way on any computer or server. This is how real companies ship software, instead of saying "it works on my machine."

1. Install Docker

Download Docker Desktop from https://www.docker.com/products/docker-desktop and install it. Make sure it's running before the next steps.

2. Build the image

From the main project folder:

docker build -t task-assistant .

This reads the Dockerfile, installs everything, and builds your indexed documents right into the image.

3. Run the container

Your Groq key still needs to be provided — we never bake secrets into the image itself. Run:

docker run -p 8000:8000 --env-file .env task-assistant

4. Test it

Open http://127.0.0.1:8000/docs — same as before, but now it's running inside a container. Try the new /chat endpoint with a message like:

{"message": "add a task to finish my resume"}

What we'll add next

• Deploy on AWS or Render
• Add basic evaluation/logging

Step 9 — Frontend

There's now a real webpage, not just the /docs testing page. It lives in app/static/ (index.html, style.css, app.js) and is served automatically by FastAPI at the site's root URL.

Try it

pip install -r requirements.txt
uvicorn app.main:app --reload

Open http://127.0.0.1:8000 (not /docs this time) — you'll see a proper chat interface with a task sidebar. Type a message like "add a task to finish my resume" and watch the assistant respond, show which tools it used (a small transparency feature — most portfolio projects skip this), and update the task list automatically.

Note: /docs still works too, for testing individual endpoints directly.