Build an Auto-Summarizing AI Agent on Civo Kubernetes with GPUs

Picture this: you upload a PDF to a folder, and within seconds, a structured summary appears next to it. No manual triggers. No complicated workflows. Just effortless document processing that actually works.

That’s exactly what we’re building today: an automated summarization agent running on Civo Kubernetes with GPU support. It watches a Civo Object Store bucket, detects new files, sends them to a relaxAI-powered summarizer, and stores the results as JSON sidecars. The whole thing runs 24/7, with minimal infrastructure cost, and proves that AI pipelines don't need to be enterprise nightmares.

Prerequisites

As well as having basic Kubernetes knowledge, you will need to ensure that the following is in place before we dive in:

A Civo account (this will require access to GPU-enabled nodes in your chosen Civo region)
Docker installed locally
Python 3.9+ installed
relaxAI API access
kubectl CLI configured and ready

Project folder structure

First, let's set up our project structure. Create this locally:

1civo-summarizer-agent/
2├── summarizer/
3│   ├── app.py
4│   ├── requirements.txt
5│   └── Dockerfile
6├── watcher/
7│   ├── watcher.py
8│   ├── requirements.txt
9│   └── Dockerfile
10├── k8s/
11│   ├── namespace.yaml
12│   ├── summarizer-deployment.yaml
13│   ├── watcher-deployment.yaml
14│   └── secret.yaml

Step 1: Create a GPU Kubernetes cluster on Civo

First, provision a GPU-enabled cluster:

Log in to the Civo Dashboard
Create a new Kubernetes cluster
Add a GPU node pool (one node is sufficient for this demo)
Download your kubeconfig
Connect to the cluster by running set KUBECONFIG=path-to-kubeconfig-file in your terminal (use export instead of set on Linux or macOS).

Verify connectivity:

1kubectl get nodes
2kubectl get pods -A

Create a namespace for our project:

Create k8s/namespace.yaml:

1apiVersion: v1
2kind: Namespace
3metadata:
4  name: summarizer-agent

Apply it:

1kubectl apply -f k8s/namespace.yaml
2kubectl config set-context --current --namespace=summarizer-agent

Step 2: Set up Civo Object Store

Civo's Object Store is S3-compatible and simple to set up:

Create Object Store credentials:

In the Civo dashboard, go to Object Stores → Credentials
Click Create a new Credential
Note down your Access Key and Secret Key (you'll need these)

Create an Object Store instance:

Go to Object Stores → Create an Object Store
Name it summarizer-store
Select the same region as your cluster (e.g., lon1)
Click Create store

Create a bucket:

Click on your newly created Object Store instance
Click Create a new folder
Name it incoming-docs
Click Create folder

Your bucket URL will be like this: https://objectstore.lon1.civo.com/incoming-docs

Note: Replace lon1 with your actual region throughout this tutorial.

Step 3: Build the summarizer service (relaxAI)

This is our GPU-powered summarization engine, utilizing the relaxAI SDK.

Create summarizer/app.py:

1# ============================================================
2# 1. SETUP & CONFIGURATION
3# Initializes FastAPI, loads API key, sets up relaxAI client,
4# and defines request/response data models.
5# ============================================================
6from fastapi import FastAPI, HTTPException
7from pydantic import BaseModel
8from relaxAI import relaxAI
9import os, json
10from typing import List
11
12app = FastAPI()
13
14RELAXAI_API_KEY = os.getenv("RELAXAI_API_KEY")
15client = relaxAI(api_key=RELAXAI_API_KEY) if RELAXAI_API_KEY else None
16
17class SummarizeRequest(BaseModel):
18    content: str
19    filename: str
20
21class SummarizeResponse(BaseModel):
22    title: str
23    summary: str
24    keywords: List[str]
25    word_count: int
26    filename: str
27
28
29# ============================================================
30# 2. API ENDPOINTS
31# Provides a health check endpoint and the main summarization route.
32# ============================================================
33@app.get("/health")
34async def health():
35    return {"status": "healthy", "relaxAI_configured": client is not None}
36
37@app.post("/summarize", response_model=SummarizeResponse)
38async def summarize(request: SummarizeRequest):
39    if not client:
40        raise HTTPException(status_code=500, detail="relaxAI API key not configured")
41
42    # Limit content size to avoid token overflow
43    content_preview = request.content[:8000]
44
45    # Build summarization prompt for the model
46    prompt = f"""
47    Analyze the following document and provide a structured summary.
48
49    Document: {request.filename}
50    Content:
51    {content_preview}
52
53    Provide your response in this exact JSON format:
54    {{
55      "title": "Generated title for the document",
56      "summary": "A concise 2-3 sentence summary",
57      "keywords": ["keyword1", "keyword2", "keyword3"],
58      "word_count": <approximate word count>
59    }}
60
61    Return ONLY the JSON.
62    """
63
64
65# ============================================================
66    # 3. SUMMARIZATION LOGIC & ERROR HANDLING
67    # Sends prompt to relaxAI, cleans the response, parses JSON,
68    # and safely returns a validated structured summary.
69# ============================================================
70    try:
71        chat_completion_response = client.chat.create_completion(
72            messages=[
73                {
74                    "role": "system",
75                    "content": "You are a document analysis expert. Always respond with valid JSON only."
76                },
77                {
78                    "role": "user",
79                    "content": prompt
80                }
81            ],
82            model="Llama-4-Maverick-17B-128E",
83            temperature=0.3,
84            max_tokens=500
85        )
86
87        # Extract raw AI response
88        response_content = chat_completion_response.choices[0].message.content.strip()
89
90        # Remove markdown code fences if present
91        if response_content.startswith("```json"):
92            response_content = response_content[7:]
93        if response_content.startswith("```"):
94            response_content = response_content[3:]
95        if response_content.endswith("```"):
96            response_content = response_content[:-3]
97        response_content = response_content.strip()
98
99        # Parse model JSON output
100        summary_data = json.loads(response_content)
101        summary_data["filename"] = request.filename
102
103        return SummarizeResponse(**summary_data)
104
105    except json.JSONDecodeError as e:
106        raise HTTPException(500, f"Failed to parse AI response as JSON: {e}")
107    except Exception as e:
108        raise HTTPException(500, f"Summarization failed: {e}")
109
110
111# Run locally if executed directly
112if __name__ == "__main__":
113    import uvicorn
114    uvicorn.run(app, host="0.0.0.0", port=8000)

Create summarizer/requirements.txt:

1fastapi==0.104.1
2uvicorn==0.24.0
3relaxAI
4pydantic==2.5.0

Create summarizer/Dockerfile:

1FROM python:3.11-slim
2
3WORKDIR /app
4
5COPY requirements.txt .
6RUN pip install --no-cache-dir -r requirements.txt
7
8COPY app.py .
9
10EXPOSE 8000
11
12CMD ["python", "app.py"]

Step 4: Build the watcher agent

This pod polls Civo Object Store and orchestrates the summarization workflow.

Create watcher/watcher.py:

1# ============================================================
2# 1. SETUP & CONFIGURATION
3# Loads env variables, configures S3 client, and defines helpers.
4# ============================================================
5import boto3
6import httpx
7import json
8import time
9import os
10from botocore.client import Config
11
12S3_ENDPOINT = os.getenv("S3_ENDPOINT")
13S3_ACCESS_KEY = os.getenv("S3_ACCESS_KEY")
14S3_SECRET_KEY = os.getenv("S3_SECRET_KEY")
15S3_BUCKET = os.getenv("S3_BUCKET", "incoming-docs")
16SUMMARIZER_URL = os.getenv("SUMMARIZER_URL", "http://summarizer-service:8000")
17POLL_INTERVAL = int(os.getenv("POLL_INTERVAL", "10"))
18
19# Civo Object Store client
20s3 = boto3.client(
21    's3',
22    endpoint_url=S3_ENDPOINT,
23    aws_access_key_id=S3_ACCESS_KEY,
24    aws_secret_access_key=S3_SECRET_KEY,
25    config=Config(signature_version='s3v4')
26)
27
28def get_file_content(key: str) -&gt; str:
29    """Downloads a file and returns decoded text."""
30    try:
31        response = s3.get_object(Bucket=S3_BUCKET, Key=key)
32        content = response['Body'].read()
33        try:
34            return content.decode('utf-8')
35        except UnicodeDecodeError:
36            return content.decode('latin-1')
37    except Exception as e:
38        print(f"Error downloading {key}: {e}")
39        return None
40
41def upload_json(key: str, data: dict):
42    """Uploads JSON summary back to Object Store."""
43    try:
44        s3.put_object(
45            Bucket=S3_BUCKET,
46            Key=key,
47            Body=json.dumps(data, indent=2),
48            ContentType='application/json'
49        )
50        print(f"✓ Uploaded {key}")
51    except Exception as e:
52        print(f"Error uploading {key}: {e}")
53
54def file_needs_processing(filename: str, existing_files: set) -&gt; bool:
55    """Checks if a file doesn’t already have a .json summary."""
56    if filename.endswith('.json'):
57        return False
58    return f"{filename}.json" not in existing_files
59
60
61# ============================================================
62# 2. FILE PROCESSING LOGIC
63# Downloads a file, sends to summarizer API, and uploads results.
64# ============================================================
65async def process_file(filename: str):
66    """Handles full summarize → upload workflow for a single file."""
67    print(f"Processing {filename}...")
68
69    content = get_file_content(filename)
70    if not content:
71        print(f"✗ Could not read {filename}")
72        return
73
74    try:
75        async with httpx.AsyncClient(timeout=120.0) as client:
76            response = await client.post(
77                f"{SUMMARIZER_URL}/summarize",
78                json={"content": content, "filename": filename}
79            )
80            response.raise_for_status()
81            summary = response.json()
82
83            json_key = f"{filename}.json"
84            upload_json(json_key, summary)
85            print(f"✓ Successfully processed {filename}")
86
87    except httpx.TimeoutException:
88        print(f"✗ Timeout while processing {filename}")
89    except httpx.HTTPStatusError as e:
90        print(f"✗ HTTP error: {e.response.status_code}")
91    except Exception as e:
92        print(f"✗ Failed to process {filename}: {e}")
93
94
95# ============================================================
96# 3. WATCH LOOP
97# Polls the bucket, finds new files, and processes them continuously.
98# ============================================================
99async def watch_bucket():
100    print("="*60)
101    print("CIVO SUMMARIZER WATCHER STARTED")
102    print("="*60)
103    print(f"Bucket: {S3_BUCKET}")
104    print(f"Endpoint: {S3_ENDPOINT}")
105    print(f"Polling interval: {POLL_INTERVAL}s")
106    print(f"Summarizer URL: {SUMMARIZER_URL}")
107    print("="*60)
108
109    while True:
110        try:
111            resp = s3.list_objects_v2(Bucket=S3_BUCKET)
112
113            if 'Contents' not in resp:
114                print("Bucket is empty, waiting...")
115                time.sleep(POLL_INTERVAL)
116                continue
117
118            existing_files = {obj['Key'] for obj in resp['Contents']}
119            files_to_process = [
120                f for f in existing_files if file_needs_processing(f, existing_files)
121            ]
122
123            if files_to_process:
124                print(f"\nFound {len(files_to_process)} file(s) to process")
125                for f in files_to_process:
126                    await process_file(f)
127            else:
128                print(".", end="", flush=True)
129
130        except Exception as e:
131            print(f"\n✗ Error in watch loop: {e}")
132
133        time.sleep(POLL_INTERVAL)
134
135
136if __name__ == "__main__":
137    import asyncio
138    asyncio.run(watch_bucket())

Create watcher/requirements.txt:

1boto3==1.29.7
2httpx==0.25.1

Create watcher/Dockerfile:

1FROM python:3.11-slim
2
3WORKDIR /app
4
5COPY requirements.txt .
6RUN pip install --no-cache-dir -r requirements.txt
7
8COPY watcher.py .
9
10CMD ["python", "watcher.py"]

Step 5: Dockerization

Build and push both images to a container registry. We'll use Docker Hub for simplicity.

1# Login to Docker Hub
2docker login
3
4# Build and push summarizer
5cd summarizer
6docker build -t yourusername/civo-summarizer:latest .
7docker push yourusername/civo-summarizer:latest
8
9# Build and push watcher
10cd ../watcher
11docker build -t yourusername/civo-watcher:latest .
12docker push yourusername/civo-watcher:latest
13
14cd ..

Step 6: Deployment

Now, we will deploy everything to Kubernetes with all necessary environment variables. Create k8s/secret.yaml:

1apiVersion: v1
2kind: Secret
3metadata:
4  name: summarizer-secrets
5  namespace: summarizer-agent
6type: Opaque
7stringData:
8  S3_ENDPOINT: "https://objectstore.lon1.civo.com"  # Change region as needed
9  S3_ACCESS_KEY: "your-civo-access-key-here"
10  S3_SECRET_KEY: "your-civo-secret-key-here"
11  S3_BUCKET: "incoming-docs"
12  RELAXAI_API_KEY: "your-relaxAI-api-key-here"

CRITICAL: Replace all placeholder values with your actual credentials from step 2!

Create k8s/summarizer-deployment.yaml:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: summarizer
5  namespace: summarizer-agent
6spec:
7  replicas: 1
8  selector:
9    matchLabels:
10      app: summarizer
11  template:
12    metadata:
13      labels:
14        app: summarizer
15    spec:
16      containers:
17      - name: summarizer
18        image: yourusername/civo-summarizer:latest
19        ports:
20        - containerPort: 8000
21        env:
22        - name: RELAXAI_API_KEY
23          valueFrom:
24            secretKeyRef:
25              name: summarizer-secrets
26              key: RELAXAI_API_KEY
27        resources:
28          requests:
29            memory: "2Gi"
30            cpu: "1000m"
31            nvidia.com/gpu: "1"
32          limits:
33            memory: "4Gi"
34            cpu: "2000m"
35            nvidia.com/gpu: "1"
36        livenessProbe:
37          httpGet:
38            path: /health
39            port: 8000
40          initialDelaySeconds: 30
41          periodSeconds: 10
42        readinessProbe:
43          httpGet:
44            path: /health
45            port: 8000
46          initialDelaySeconds: 10
47          periodSeconds: 5
48      nodeSelector:
49        node.kubernetes.io/instance-type: g4-g.4xlarge.kube.cluster  # Adjust based on your GPU node type
50---
51apiVersion: v1
52kind: Service
53metadata:
54  name: summarizer-service
55  namespace: summarizer-agent
56spec:
57  selector:
58    app: summarizer
59  ports:
60  - protocol: TCP
61    port: 8000
62    targetPort: 8000
63  type: ClusterIP

Create k8s/watcher-deployment.yaml:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: watcher
5  namespace: summarizer-agent
6spec:
7  replicas: 1
8  selector:
9    matchLabels:
10      app: watcher
11  template:
12    metadata:
13      labels:
14        app: watcher
15    spec:
16      containers:
17      - name: watcher
18        image: yourusername/civo-watcher:latest
19        env:
20        - name: S3_ENDPOINT
21          valueFrom:
22            secretKeyRef:
23              name: summarizer-secrets
24              key: S3_ENDPOINT
25        - name: S3_ACCESS_KEY
26          valueFrom:
27            secretKeyRef:
28              name: summarizer-secrets
29              key: S3_ACCESS_KEY
30        - name: S3_SECRET_KEY
31          valueFrom:
32            secretKeyRef:
33              name: summarizer-secrets
34              key: S3_SECRET_KEY
35        - name: S3_BUCKET
36          valueFrom:
37            secretKeyRef:
38              name: summarizer-secrets
39              key: S3_BUCKET
40        - name: SUMMARIZER_URL
41          value: "http://summarizer-service:8000"
42        - name: POLL_INTERVAL
43          value: "10"
44        resources:
45          requests:
46            memory: "256Mi"
47            cpu: "100m"
48          limits:
49            memory: "512Mi"
50            cpu: "500m"

Deploy everything:

1# Make sure you're in the right namespace
2kubectl config set-context --current --namespace=summarizer-agent
3
4# Apply secret (make sure you've edited it with real credentials!)
5kubectl apply -f k8s/secret.yaml
6
7# Deploy summarizer with GPU
8kubectl apply -f k8s/summarizer-deployment.yaml
9
10# Deploy watcher
11kubectl apply -f k8s/watcher-deployment.yaml
12
13# Check deployment status
14kubectl get pods -n summarizer-agent
15kubectl get services -n summarizer-agent

1# Watch pod status
2kubectl get pods -n summarizer-agent -w
3
4# Check logs
5kubectl logs -f deployment/summarizer -n summarizer-agent
6kubectl logs -f deployment/watcher -n summarizer-agent

Step 7: End-to-end testing

Time to see your AI pipeline in action!

Go to Civo Dashboard → Object Stores → incoming-docs → Browse Files
Click Upload File
Upload: Sample.pdf - A sample file containing the text content
Watch logs:

1Step 7: End-to-end testing
2Time to see your AI pipeline in action!
3
4Go to Civo Dashboard → Object Stores → incoming-docs → Browse Files
5Click Upload File
6Upload: Sample.pdf - A sample file containing the text content
7Watch logs:

Refresh bucket — you will see:

1Sample.pdf
2sample.pdf.json

Your automated summarization pipeline works:

Troubleshooting

If the summaries aren't being generated:

1# Check pod status
2kubectl get pods -n summarizer-agent
3
4# Check summarizer health
5kubectl port-forward deployment/summarizer 8000:8000 -n summarizer-agent
6curl http://localhost:8000/health
7
8# Check watcher logs for errors
9kubectl logs deployment/watcher -n summarizer-agent | grep -i error

Summary

This tutorial demonstrates how to build a production-ready AI automation pipeline without the complexity typically associated with enterprise AI platforms. Using Civo’s GPU-powered Kubernetes, GPU resources are provisioned in minutes, enabling fast experimentation and scalable production workflows without long lead times or operational overhead.

By combining Object Store, lightweight Kubernetes pods, and a simple polling architecture with relaxAI for inference, the pipeline remains efficient, cost-effective, and easy to operate at scale. The result is a practical blueprint for AI automation that can grow from small experiments to high-volume document processing, proving that modern AI pipelines can be both powerful and straightforward when built on the right foundation.

Additional resources

If you are interested in learning more about this topic, check out some of these resources:

Build an auto-summarizing folder agent on Civo

Prerequisites

Project folder structure

Step 1: Create a GPU Kubernetes cluster on Civo

Step 2: Set up Civo Object Store

Step 3: Build the summarizer service (relaxAI)

Step 4: Build the watcher agent

Step 5: Dockerization

Step 6: Deployment

Step 7: End-to-end testing

Troubleshooting

Summary

Additional resources

Further Reading

Automated knowledge-graph generator on Civo

LLM-powered incident analysis dashboard on Civo

Optimize GPU costs for machine learning with just-in-time Kubernetes scaling

Automated knowledge-graph generator on Civo

LLM-powered incident analysis dashboard on Civo

Optimize GPU costs for machine learning with just-in-time Kubernetes scaling

Company

Company

Public Cloud

Public Cloud

Private Cloud

Private Cloud

Civo AI

Civo AI

Solutions

Solutions

Resources

Resources

Contact

Contact

Legal

Social