Fact Checked ✓

guides

Depth0%

DeployingPaperclip:AnAdvancedAIAgentTutorial

Master Paperclip AI agent deployment on Hostinger. This advanced guide covers setup, configuration, and best practices for developers. See the full setup guide.

Harit NarkeEditor-in-Chief · Apr 7

Join Circle

Deploying Paperclip: An Advanced AI Agent Tutorial

📋 At a Glance

Alright, let's get the boring but necessary stuff out of the way first.

Difficulty: Intermediate to Advanced
Time required: 45-90 minutes (not counting your initial environment setup, which always takes longer than you think)
Prerequisites:
- Familiarity with Python 3.9+
- Working knowledge of Git and command-line interfaces
- Understanding of environment variables and basic server administration
- An active Hostinger account with SSH access and a configured web server (e.g., Nginx/Apache)
- Basic understanding of AI agent concepts and API keys (e.g., OpenAI, Anthropic)
Works on: Linux (Ubuntu 22.04+ recommended for Hostinger), macOS, Windows (WSL2 recommended)

What is Paperclip and why is it considered "insane"?

So, what's the deal with Paperclip? It's a modular AI agent framework for building, deploying, and managing complex, autonomous AI systems. The kind that can actually reason through multiple steps and use tools.

The "insane" part? That comes from its ability to orchestrate crazy-complex workflows, hook up all sorts of AI models and APIs, and keep long-running agent processes humming. Think of it like a fully automated, mini "AI company" – that's the marketing spiel. Forget simple prompt tweaks; this is about solid agent architecture, memory that actually works, and tools getting called when they need to be.

Its real strength? You can define roles for agents, hand them tools, manage their shared memory, and get them talking to each other to solve big problems. I've seen enough "AI wrappers" that just call an LLM API; Paperclip actually gives you a structured setup for agents to look at their own work, fix their mistakes, and remember things across sessions. That's what makes it ready for production. And yeah, it's built for scale, so adding your own tools or models isn't a hair-pulling exercise.

How Do I Prepare My Environment for Paperclip Deployment?

Alright, getting your environment ready. Don't skimp on this; it's where most people screw up. We're talking OS updates, Python, dependencies, and actually managing your API keys like a pro. Skipping these steps means chasing baffling runtime errors later. And since Paperclip's an agentic beast, make sure you've got enough compute power and network access.

I'm assuming you're on a Linux server here, probably Ubuntu 22.04 LTS, which is common with Hostinger. For local dev (macOS, Windows with WSL2), the Python stuff is similar, but your server configs (Nginx/Apache) will obviously be different.

1. Update System Packages and Install Core Dependencies

What: First things first: update your server's package lists, upgrade everything, then install the essential dev tools. Why: You want a stable, secure base system, right? And you'll need git, build-essential, and venv for Python work. Don't skip build-essential; I've wasted hours on missing compilers. How: Access your Hostinger server via SSH and execute the following commands.

# For Ubuntu/Debian-based systems
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-venv git build-essential

✅ What you should see: Output indicating packages were updated and installed cleanly. Verify git with git --version if you're paranoid, like me.

2. Set Up a Dedicated Python Virtual Environment

What: Spin up an isolated Python virtual environment just for Paperclip. No shared environments, please. Why: Avoids dependency hell, plain and simple. You don't want Paperclip tripping over some other project's outdated library. This is Python deployment 101. How: Navigate to your desired deployment directory (create it if it doesn't exist) and create the venv.

# Navigate to your project directory (create if it doesn't exist)
mkdir -p ~/paperclip_app
cd ~/paperclip_app

# Create a virtual environment named 'pc_env'
python3 -m venv pc_env

# Activate the virtual environment
source pc_env/bin/activate

✅ What you should see: Your terminal prompt should show (pc_env) at the start. If not, something's wrong, and you're not in the venv.

3. Clone the Paperclip Repository and Install Requirements

What: Grab the Paperclip source code and pull in all its Python dependencies inside that virtual environment. Why: That's the core framework and all its required libraries. No framework runs bare. How: Assuming you are in ~/paperclip_app with pc_env active.

# Clone the Paperclip repository (replace with actual URL if known, or a placeholder)
# For this guide, we'll assume a public GitHub repository.
git clone https://github.com/PaperclipAI/paperclip-core.git .

# Install dependencies from requirements.txt
# This file defines all Python packages Paperclip needs.
pip install -r requirements.txt

⚠️ Warning: Seriously, requirements.txt is crucial. If it's messed up or missing, pip install -r will just barf. Also, check your network access to PyPI – sometimes firewalls cause silent failures during pip installs. I've seen it happen. ✅ What you should see: A bunch of Collecting ... Installing ... Successfully installed ... messages. No errors.

4. Configure Environment Variables Securely

What: Create a .env file. This is where your API keys and database connection strings really belong. And make sure Git never sees it. Why: Hardcoding credentials? That's a rookie mistake and a massive security hole. Environment variables are the only sane way to manage secrets and switch configs between dev, staging, and prod. Trust me, I've had to fix enough breaches from committed keys. How: Create a .env file in your ~/paperclip_app directory. This is a critical step often overlooked in quick tutorials.

# Create the .env file
nano .env

Add the following placeholder variables. Replace these immediately with your actual, non-dummy keys and settings. Don't be that person who leaves sk-xxxxxxxx in production.

# .env file for Paperclip Configuration
PAPERCLIP_API_KEY="your_paperclip_api_key_if_applicable"
OPENAI_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
ANTHROPIC_API_KEY="sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
DATABASE_URL="sqlite:///./paperclip.db" # Example for SQLite, replace for PostgreSQL/MySQL
PAPERCLIP_AGENT_MAX_TOKENS=4096
PAPERCLIP_LOG_LEVEL="INFO"

Save and exit (Ctrl+X, Y, Enter for nano).

What: Now, this is absolutely critical. Make sure .env is ignored by Git. Why: This prevents you from ever accidentally pushing sensitive credentials to your public repo. Classic vulnerability, happens all the time. How: Create or modify the .gitignore file in your ~/paperclip_app directory.

nano .gitignore

Add the following line:

# .gitignore
.env

Save and exit.

✅ What you should see: Your .env file should be there with your real config. Run git status; .env should show as untracked, but not suggested for commit. If it is, fix your .gitignore now.

What are the critical configuration steps for Paperclip on Hostinger?

Now we're moving Paperclip from 'runs on my laptop' to 'actually works in production on Hostinger.' That means persistent storage, a proper web server for API calls, and keeping the process alive. Pay close attention to Hostinger's resource limits here; they can be brutal.

1. Database Configuration for Persistent State

What: You need a persistent database for Paperclip's memory and state. Agents aren't useful if they forget everything on restart. Why: Autonomous agents need to remember context, learn, and maintain state across restarts. SQLite is fine for quick tests, but for anything serious, you'll want PostgreSQL or MySQL. Don't be cheap on the database for production. How:

For SQLite (development/small scale): The default DATABASE_URL="sqlite:///./paperclip.db" in .env is often sufficient. The paperclip.db file will be created in your project root. Just make sure your user has write permissions to that directory.
For PostgreSQL/MySQL (production on Hostinger): 1. Create Database on Hostinger: Log into your Hostinger hPanel. Navigate to "Databases" -> "Management" and create a new database and user. Seriously, write down the credentials somewhere safe, not on a sticky note under your monitor. Note the database name, username, password, and host. 2. Install Database Driver: Activate your virtual environment (source pc_env/bin/activate) and install the appropriate Python driver:
```
# For PostgreSQL (use psycopg2-binary for simpler installs)
pip install psycopg2-binary
# For MySQL
pip install mysqlclient
```

 3.  **Update .env:** Modify `DATABASE_URL` in your `~/paperclip_app/.env` file.

     ```ini
     # Example for PostgreSQL
     DATABASE_URL="postgresql://user:password@host:port/database_name"
     # Example for MySQL
     DATABASE_URL="mysql+mysqlconnector://user:password@host:port/database_name"
     ```
     Replace `user`, `password`, `host`, `port`, and `database_name` with your Hostinger database credentials.

Verify: When Paperclip starts, it'll try to connect. Check your logs for Database connection error messages.

2. Web Server Integration (Nginx/Apache) for API Access

What: We need a proper web server, like Nginx, to sit in front of Paperclip's application server (Gunicorn). It's a reverse proxy, plain and simple. Why: Exposing your raw Python app server directly is dumb, insecure, and inefficient. Nginx handles requests, SSL (critical!), static files, and generally acts as a shield. Essential for production. How:

Install Gunicorn: Activate your pc_env and install Gunicorn.
```
pip install gunicorn
```

Create Gunicorn Service File (Optional but recommended for systemd): If you're lucky enough to have VPS/Cloud access, systemd is the way to go for process management. Shared hosting usually means you'll be using screen or some other hack, or relying on Hostinger's often-limited process manager. For this guide, I'm assuming you have a proper VPS/Cloud setup where systemd works.

sudo nano /etc/systemd/system/paperclip.service

Add the following content (adjust paths and user). Important: Adjust your_ssh_user and the ExecStart line to point to your actual wsgi.py (or main.py if that's where your Flask/FastAPI app object lives). I've debugged countless 'service won't start' issues because of wrong paths here.

[Unit]
Description=Gunicorn instance to serve Paperclip AI
After=network.target

[Service]
User=your_ssh_user # Replace with your Hostinger SSH username
Group=www-data
WorkingDirectory=/home/your_ssh_user/paperclip_app
Environment="PATH=/home/your_ssh_user/paperclip_app/pc_env/bin"
ExecStart=/home/your_ssh_user/paperclip_app/pc_env/bin/gunicorn --workers 3 --bind unix:/home/your_ssh_user/paperclip_app/paperclip.sock wsgi:app # Assuming 'app' in 'wsgi.py'
# Or if your entry point is 'main.py' with a Flask/FastAPI app object:
# ExecStart=/home/your_ssh_user/paperclip_app/pc_env/bin/gunicorn --workers 3 --bind unix:/home/your_ssh_user/paperclip_app/paperclip.sock main:app
Restart=always

[Install]
WantedBy=multi-user.target

Save and exit. Then enable and start:

sudo systemctl daemon-reload
sudo systemctl start paperclip
sudo systemctl enable paperclip

Configure Nginx: Now for Nginx. Create a config file for your domain. This is where the magic happens, and also where most people get tripped up.

sudo nano /etc/nginx/sites-available/your_domain

Add the following (replace your_domain.com and /home/your_ssh_user):

server {
    listen 80;
    server_name your_domain.com www.your_domain.com;

    # Redirect HTTP to HTTPS (seriously, always do this)
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your_domain.com www.your_domain.com;

    ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem; # Managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem; # Managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    client_max_body_size 100M; # Increase for large inputs to agents. Otherwise, you'll see Nginx throwing 413 errors, which are always fun to debug.

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/your_ssh_user/paperclip_app/paperclip.sock; # Make sure this socket path matches your Gunicorn config
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Serve static files directly if Paperclip has a UI
    location /static/ {
        alias /home/your_ssh_user/paperclip_app/static/; # Adjust if your static files are elsewhere
    }
}

Save and exit. Then link, test, and restart Nginx:

sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

⚠️ Warning: Again, for Hostinger shared hosting, direct Nginx config like this is probably off-limits. You'll be stuck with their hPanel proxy settings, .htaccess for Apache, or whatever limited app deployment they offer. This Nginx setup is strictly for Hostinger VPS/Cloud. ✅ What you should see: nginx: configuration file /etc/nginx/nginx.conf syntax is ok and nginx: configuration file /etc/nginx/nginx.conf test is successful. If not, check your syntax carefully – a missing semicolon is a classic. After restarting, try hitting your domain. If Nginx isn't serving, check its error logs (usually /var/log/nginx/error.log).

3. Hostinger-Specific Resource Management & Process Monitoring

What: You need to keep an eye on Hostinger's resource limits and monitor Paperclip's processes. Otherwise, things will break. Why: Shared hosting is brutal with CPU, RAM, and process limits. AI agents are resource hogs. Hit those limits, and your service goes down. Period. How:

Monitor Resource Usage: Fire up htop (if available) or top via SSH. Watch your Gunicorn workers. If they're maxing out CPU or RAM, you need fewer --workers or more optimized agent code. Or a bigger server.
```
htop
```
Manage Processes (Shared Hosting): If systemd is a pipe dream (i.e., you're on shared hosting), screen is your best friend for keeping processes alive after you disconnect SSH.
```
# Start a new screen session
screen -S paperclip_session

# Inside the screen session, activate venv and start Gunicorn
cd ~/paperclip_app
source pc_env/bin/activate
gunicorn --workers 1 --bind 0.0.0.0:8000 wsgi:app # Use 0.0.0.0:8000 for direct port if no Nginx proxy

# Detach from screen (Ctrl+A, then D)
```
To reattach: screen -r paperclip_session.

⚠️ Warning: Seriously, Hostinger shared hosting will kill long-running processes without warning. Don't say I didn't warn you. For anything serious with Paperclip, you need their Cloud or VPS plans.
Check Hostinger Logs: Beyond Paperclip's own logs, check your hPanel for server-level errors (PHP, access, etc.) and specific application logs if available through their interface. Sometimes the problem isn't your code, it's the environment.

How Do I Deploy and Verify Paperclip's Core Services?

Time to actually bring Paperclip online and kick the tires. We'll start the server, then run some tests to make sure the API, database, and a basic agent task are all actually working. Don't assume anything until you verify it.

1. Start the Paperclip Application Server

What: Fire up the Gunicorn server. This makes Paperclip's API available. Why: No server, no API. Simple. How:

If using systemd (VPS/Cloud):

sudo systemctl start paperclip
sudo systemctl status paperclip # Check logs for errors

If using screen (Shared Hosting):

screen -r paperclip_session # Reattach if detached
# If Gunicorn isn't running, start it:
cd ~/paperclip_app
source pc_env/bin/activate
gunicorn --workers 1 --bind 0.0.0.0:8000 wsgi:app # Or your specific bind address
# Then detach with Ctrl+A, D

✅ What you should see: For systemd, Active: active (running). For screen, Gunicorn output showing workers starting and listening on the specified address/socket.

2. Verify API Endpoint Accessibility

What: Send a quick HTTP request to Paperclip's /status endpoint to see if it's alive. Why: Confirms Nginx is forwarding correctly and Paperclip itself is actually responding. It's your first sanity check. How: Use curl from your local machine or another server. Replace your_domain.com with your actual domain or IP.

curl -X GET https://your_domain.com/api/v1/status

⚠️ Warning: That /api/v1/status endpoint? It might be different in Paperclip's actual docs. Always check. Getting an Nginx error page or a timeout usually means your Nginx or Gunicorn configs are borked. ✅ What you should see: A JSON response, hopefully {"status": "ok", "version": "1.2.0", "message": "Paperclip AI services operational"} or similar. If you see Nginx's 502 Bad Gateway, Gunicorn isn't talking to Nginx. Debug time.

3. Test Database Connectivity and Basic Agent Invocation

What: Run a bare-bones Paperclip agent task. This should hit the database and probably an external AI model. Why: This is your end-to-end check. Database connection, API keys, and Paperclip's agent orchestration – all verified in one go. How: This typically involves a Python script or a direct API call to Paperclip's agent creation/invocation endpoint.

Via Python Script (example test_agent.py in ~/paperclip_app):

# test_agent.py
import os
import requests
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Assume Paperclip exposes an API to create/run agents
PAPERCLIP_API_URL = os.getenv("PAPERCLIP_API_URL", "http://localhost:8000/api/v1")
# If accessed via Nginx:
# PAPERCLIP_API_URL = os.getenv("PAPERCLIP_API_URL", "https://your_domain.com/api/v1")

def run_test_agent():
    try:
        # Example: Create a simple agent task
        response = requests.post(
            f"{PAPERCLIP_API_URL}/agents/run",
            json={
                "name": "basic_qa_agent",
                "task": "What is the capital of France?",
                "config": {
                    "model": "gpt-4o", # Or other model configured in Paperclip
                    "max_tokens": 100
                }
            },
            headers={"Authorization": f"Bearer {os.getenv('PAPERCLIP_API_KEY')}"} # If API key is used
        )
        response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
        print("Agent run successful:")
        print(response.json())

        # Example: Check agent's memory/state (requires a specific Paperclip API)
        # memory_response = requests.get(f"{PAPERCLIP_API_URL}/agents/basic_qa_agent/memory")
        # print("Agent memory:", memory_response.json())

    except requests.exceptions.RequestException as e:
        print(f"Error communicating with Paperclip API: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    run_test_agent()

Important: Adjust PAPERCLIP_API_URL in the script to match your deployment (localhost if running on server, or your domain if Nginx is fronting it). Run this script from your local machine or the server (with pc_env activated if on server).

# On your local machine (if API is public) or server
python test_agent.py

✅ What you should see: A JSON output from the test_agent.py script, showing the agent's response to the task (e.g., {"result": "The capital of France is Paris."}). If you get errors, check everything: API keys, database connection, and Paperclip's own logs for deeper insights. This is where real debugging starts.

What common pitfalls should I avoid when scaling Paperclip agents?

Okay, you got one agent working. Now you want to scale? Prepare for pain. This is where resource limits, concurrency, and proper error handling become a nightmare if you don't plan ahead. Moving from a single-agent demo to a high-throughput production system is where most people hit a wall with resource contention, API rate limits, and agents just silently dying.

1. Resource Contention and Hostinger Limits

What: Don't overwhelm Hostinger with too many agents or tasks. Their CPU and RAM limits are real, and they will kill your processes. Why: AI agent workloads are hungry. Shared hosting isn't built for that. You will hit limits, and your service will go down or get throttled. Period. How:

Monitor Aggressively: Use htop and Hostinger's resource usage graphs in hPanel. Identify peak usage times.
Limit Gunicorn Workers: Start with gunicorn --workers 1 and incrementally increase if htop shows you have headroom. Never guess.
Optimize Agent Code: This is on you. Minimize the data passed to LLMs. Summarize previous interactions instead of re-sending entire histories. Ensure external tools/APIs used by agents are efficient and don't introduce long blocking I/O operations. Implement asynchronous processing for I/O-bound tasks to maximize concurrency without increasing worker count. Don't just throw bigger models at it and hope for the best.
Consider Upgrading: If you're constantly hitting limits, stop kidding yourself. Upgrade to a Hostinger Cloud or VPS plan. Shared hosting for Paperclip is asking for trouble.

⚠️ Warning: Hit resource limits too often on shared hosting, and your account might get suspended. Seriously. Hostinger doesn't play around with abusers. Proactive monitoring is key.

2. API Rate Limits and Cost Management

What: You will hit rate limits from OpenAI, Anthropic, and other APIs. Plan for it. Why: Too many requests mean 429 Too Many Requests errors, broken agent workflows, and possibly unexpected bills. No one wants a 429 fest. How:

Rate Limiting Libraries: Integrate client-side rate limiting (e.g., tenacity for Python retries with backoff) into Paperclip's API client wrappers. It's a lifesaver. Don't write your own.
Asynchronous Queues: Use message queues (e.g., Redis Queue, Celery) to decouple agent task submission from LLM inference, allowing for controlled, throttled calls.
Batching: If possible, batch smaller requests into larger, single API calls to reduce the number of requests.
Monitor API Usage: Regularly check your AI provider dashboards for usage and cost. Implement budget alerts; you don't want a surprise bill.

✅ What you should see: Fewer 429 errors in Paperclip logs, consistent agent performance even under load, and predictable API costs. That's the goal.

3. Robust Error Handling and Observability

What: Build your agents and infrastructure to handle errors gracefully, log everything, and monitor like your job depends on it. Because it does. Why: Agents are unpredictable. They'll hit weird states, tools will fail, external services will flake out. If you don't handle this, agents will get stuck, give wrong answers, or just crash your system silently. You need to know what went wrong and when. How:

Structured Logging: Configure Paperclip and its agents to emit structured logs (JSON format) with relevant context (agent ID, task ID, tool used, error message). If you're serious, push these to an ELK stack or Grafana Loki for centralized log management. Don't just print().
Agent Self-Correction: Implement mechanisms within agents for self-correction or retry logic upon encountering errors. For example, if a tool call fails, the agent should attempt an alternative approach or ask for clarification.
Circuit Breakers: For external API calls, implement circuit breakers to prevent cascading failures when a dependency is unhealthy. It's basic distributed systems engineering.
Alerting: Set up alerts (email, Slack, PagerDuty) for critical errors, high error rates, or agent failures. You need to know before your users tell you something's broken.

✅ What you should see: Detailed logs for every agent action and error, enabling quick debugging. System alerts for critical issues, allowing proactive intervention before users are impacted. Agents gracefully handling temporary failures.

When Paperclip Is NOT the Right Choice

Paperclip is powerful, sure, but it's not a silver bullet. Its agentic capabilities add a ton of overhead and complexity. If you're not building a full-blown "AI company," it's probably overkill, and its architectural demands will just slow you down.

Simple, Single-Turn AI Interactions: If all you need is a single prompt-response from an LLM – a basic chatbot, or just generating text from a direct input – Paperclip's agent orchestration, memory, and tool integration is absolute overkill. Just hit the LLM API directly, or use a much lighter wrapper like LangChain/LlamaIndex without the full agentic loop. Don't over-engineer it.
Strictly Rule-Based Systems: If your task is purely deterministic and rule-based, with no need for an AI to make dynamic decisions or use external tools, then just build a traditional software system or a finite state machine. It'll be more reliable, predictable, and way easier to debug than a generative AI agent trying to act smart.
Extremely Resource-Constrained Environments: As I've already hammered home, shared hosting will choke on Paperclip. If you're stuck with severe CPU, RAM, or process limits and can't upgrade, Paperclip's multi-agent, persistent nature will lead to constant performance problems or outright service interruptions. You'll be better off with simpler, stateless AI microservices.
Projects with Minimal AI Expertise In-House: Paperclip needs folks who actually understand AI agents, system architecture, and maybe even distributed systems. If your team is light on this expertise, the learning curve and debugging nightmares will eat your development time and maintenance budget alive. Stick to simpler, managed AI services until you've got the talent.
High-Frequency, Low-Latency Tasks Requiring Guaranteed Response Times: Yes, Paperclip aims for efficiency, but generative AI agents, by their nature, are non-deterministic and involve multi-step reasoning. That means variable latency. If you're building something where every millisecond counts – like real-time trading or super high-throughput content moderation – the agentic overhead will be a bottleneck. Direct, optimized model inference is your only play there.

#Frequently Asked Questions

Can I run Paperclip on shared hosting plans from providers other than Hostinger? Look, technically, if your shared host gives you Python and SSH, you could try. But shared hosting has brutal CPU, RAM, and process limits. It will severely cripple Paperclip, especially for anything multi-agent or long-running. For anything production-worthy, I recommend VPS or Cloud hosting. Don't waste your time with shared if you're serious.

How do I update Paperclip to a newer version without downtime? Updating Paperclip usually means a git pull, pip install -r requirements.txt to grab new dependencies, and then a graceful restart of the Gunicorn service. For zero-downtime? You're talking blue/green deployments or rolling updates with Docker Swarm or Kubernetes. That's way beyond a basic Hostinger setup, and honestly, a different kind of guide.

My Paperclip agents are generating irrelevant or nonsensical responses. What should I check? When agents go off the rails like that, it's almost always one of these: messed-up prompt engineering, poorly defined tools, or bad memory management. Double-check your prompts for clarity, make sure your tools are returning what Paperclip expects, and examine the agent's memory – is it getting polluted or just not retaining the right context? And, of course, confirm your API keys and model availability are correct. The basics first.

#Quick Verification Checklist

Alright, you've done the work. Now, hit this checklist to make sure you haven't missed anything crucial.

Python virtual environment pc_env is active.
All requirements.txt dependencies are installed.
.env file exists with correct API keys and database credentials, and is in .gitignore.
Gunicorn service is running and accessible (via systemctl status paperclip or screen).
Nginx (or other web server) is correctly configured as a reverse proxy to Gunicorn.
curl https://your_domain.com/api/v1/status returns an "ok" status.
A basic agent task (e.g., via test_agent.py) successfully executes and returns a coherent response.

Keep Reading

All Guides →