TaskingAI Tutorial: Deploy and Build Your First AI Assistant in 10 Minutes

Get TaskingAI Running in 10 Minutes — A Real Walkthrough

I'm going to walk you through deploying TaskingAI, creating an assistant with RAG capabilities, and actually talking to it. No fluff, no marketing — just the commands I ran and the results I got. Grab a coffee (or tea, I don't judge), and let's go.

Step 1: Docker Setup (This Takes 2 Minutes)

TaskingAI ships as a Docker image, which means zero dependency hell. Here's what I ran:

docker pull taskingai/taskingai-server:latest
docker run -d --name taskingai \
  -p 8080:8080 \
  -v ./taskingai_data:/data \
  taskingai/taskingai-server:latest

Let it spin up — on my 4-core machine with 8GB RAM, cold start took about 45 seconds. You'll know it's ready when you see logs like "TaskingAI server started on port 8080". If you get port conflicts (I did — my n8n was already on 8080), just change the left port: -p 8081:8080.

Step 2: Create Your First Assistant

Once the server is running, you interact with it via the RESTful API. TaskingAI uses a scoped API design — everything lives under an "assistant" model. Let me show you the create flow:

# Create an assistant
curl -X POST http://localhost:8080/v1/assistants \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Knowledge Assistant",
    "model": "gpt-4o",
    "description": "A helpful assistant with RAG capabilities",
    "instructions": "You are a helpful assistant. Answer questions based on the provided context.",
    "retrieval": {
      "enabled": true,
      "chunk_size": 512,
      "chunk_overlap": 20
    }
  }'

# Response (abbreviated)
{"assistant_id": "asst_abc123", "name": "My Knowledge Assistant", ...}

Here's the thing about the instructions field — it's basically your system prompt. I recommend being specific about when the assistant should use RAG vs. when it should rely on its training data. I didn't do this at first, and my assistant would sometimes hallucinate answers instead of pulling from the documents I uploaded.

Step 3: Upload Documents for RAG

This is where TaskingAI shines. Upload a document and it automatically chunks, embeds, and indexes it:

# Upload a document
curl -X POST http://localhost:8080/v1/assistants/asst_abc123/documents \
  -H "Content-Type: multipart/form-data" \
  -F "file=@/path/to/your/document.pdf" \
  -F "metadata={\"title\":\"My Knowledge Base\"}"

# Check processing status
curl http://localhost:8080/v1/assistants/asst_abc123/documents

# Response
{"documents": [{"document_id": "doc_xyz", "status": "ready", "chunks": 47}]}

Supported formats: PDF, TXT, MD, DOCX, and even HTML. The chunking is intelligent — it tries to split at natural boundaries (paragraphs, sections) rather than arbitrary token counts. If you see "processing" stuck for more than a minute, the document might be too large. I had a 200-page PDF that took about 3 minutes to fully index.

Step 4: Function Calling — Give Your Assistant Tools

This is my favorite part. You define tools as JSON schemas (OpenAI-compatible format), and the assistant decides when to call them. Here's a simple calculator tool:

curl -X POST http://localhost:8080/v1/assistants/asst_abc123/tools \
  -H "Content-Type: application/json" \
  -d '{
    "type": "function",
    "function": {
      "name": "calculate",
      "description": "Perform a mathematical calculation",
      "parameters": {
        "type": "object",
        "properties": {
          "expression": {
            "type": "string",
            "description": "The mathematical expression to evaluate"
          }
        },
        "required": ["expression"]
      }
    }
  }'

The assistant will automatically call this tool when it needs to perform calculations. You can define as many tools as you need — database queries, API calls, web scraping, whatever.

Step 5: Chat With Your Assistant

Now the fun part — actually talking to it:

# Start a conversation
curl -X POST http://localhost:8080/v1/assistants/asst_abc123/chats \
  -H "Content-Type: application/json" \
  -d '{"name": "My First Chat"}'

# {"chat_id": "chat_def456"}

# Send a message
curl -X POST http://localhost:8080/v1/chats/chat_def456/messages \
  -H "Content-Type: application/json" \
  -d '{
    "role": "user",
    "content": "What documents do I have available and what are they about?"
  }'

# Response — you'll see it retrieve from the uploaded documents
# and respond with grounded answers

The response times vary by model. GPT-4o took about 3-4 seconds for the first response on my setup. Local models via Ollama were faster (~1-2 seconds) but less accurate with complex questions. Your mileage will vary depending on hardware.

Performance Numbers (Real Data)

Final Thoughts

TaskingAI is legitimately good at what it does. It's not trying to be everything to everyone — it's a focused platform for building AI-native applications with RAG and function calling. The API is clean, the documentation is solid, and the open-source community is active. If you're building something real with AI, this will save you weeks of plumbing work.

Is it perfect? No. The built-in vector store is great for small to medium datasets but you'll need external infrastructure for millions of documents. And like most self-hosted tools, you need to think about backups, scaling, and monitoring. But for getting from zero to a working AI application in an afternoon? It's hard to beat.