🤖 AI System Administrator

An intelligent file system administrator powered by a local LLM, built with Google ADK, FastMCP, and Ollama — fully containerized and secured.

🌟 Overview

AI System Administrator is an agentic AI project that acts as an intelligent file system manager. You interact with it through natural language — ask it to read files, list directories, create folders, or check file contents — and it will carry out the operations autonomously using MCP (Model Context Protocol) tools.

The system runs entirely locally using Ollama with Llama 3.2, meaning no data is sent to external APIs. The full stack is containerized with Docker and orchestrated via Docker Compose, making it portable and easy to deploy on any machine.

✨ Features

• 💬 Natural language interface — talk to the agent like a human, it figures out what to do
• 📁 Full file system management — read, write, create, delete files and directories
• 🔍 File metadata — retrieve size, timestamps, and file type
• 🔒 Multi-layer security — protected files, blocked tools, rate limiting, and JWT authentication
• 🐳 Fully Dockerized — three isolated containers, launched with a single command
• 🔑 JWT-authenticated MCP server — only agents with valid RSA-signed tokens can access tools
• 🛡️ AI Guardrails — prompt engineering to prevent the agent from leaking sensitive information

🏗️ Architecture

The system is composed of three Docker containers communicating over an internal bridge network:

┌─────────────────────────────────────────────────────────┐
│                    Docker Network                        │
│                                                         │
│  ┌───────────────┐     ┌───────────────┐               │
│  │   Ollama      │     │  MCP Server   │               │
│  │  (Llama 3.2)  │◄────│  (FastMCP)    │               │
│  │  port: 11434  │     │  port: 8001   │               │
│  └───────────────┘     └───────┬───────┘               │
│                                │ JWT Auth               │
│                        ┌───────▼───────┐               │
│                        │     Agent     │               │
│                        │  (Google ADK) │               │
│                        │  port: 8000   │◄── User        │
│                        └───────────────┘               │
└─────────────────────────────────────────────────────────┘

🛠️ MCP Tools

The MCP server exposes the following tools to the agent:

All file paths are relative to the agent's root directory. The sanitize_path() function prevents any path traversal attacks (no .. or . escapes).

🔒 Security

Security is implemented across three layers:

1. Server Level (MCP)

• JWT Authentication — the MCP server validates RSA-signed Bearer tokens; unauthenticated requests are rejected
• Path sanitization — sanitize_path() blocks any attempt to escape the root directory
• Protected files — flag.txt is shielded from get_file_content, write_file_content, delete_path, and get_file_info
• Rate limiting — check_file_content limits repeated attempts on protected files

2. Agent Level (Callback)

• before_tool_callback — intercepts every tool call before execution; if a blocked tool is called on a protected file, access is denied immediately and the LLM never sees the content

3. Instruction Level (AI Guardrails)

• The agent's system prompt explicitly instructs it to never reveal the contents of protected files, never expose internal tools like get_security_config, and respond evasively if asked about system internals

📁 Project Structure

project-root/
├── agent/
│   ├── mcp_auth/
│   │   ├── private.pem         # RSA private key (agent signs tokens)
│   │   └── public.pem          # RSA public key
│   ├── multi_tool_agent/
│   │   ├── __init__.py
│   │   └── agent.py            # Agent definition & security callback
│   ├── Dockerfile
│   └── requirements.txt
│
├── server/
│   ├── mcp_auth/
│   │   └── public.pem          # RSA public key (server validates tokens)
│   ├── server.py               # MCP server with all tools
│   ├── Dockerfile
│   └── requirements.txt
│
└── docker-compose.yml

🚀 Getting Started

1. Clone the repository

git clone https://github.com/dansimina/System-Administrator-With-Agentic-AI
cd System-Administrator-With-Agentic-AI

2. Generate RSA key pair

mkdir -p agent/mcp_auth server/mcp_auth

# Generate private key
openssl genrsa -out agent/mcp_auth/private.pem 2048

# Extract public key
openssl rsa -in agent/mcp_auth/private.pem -pubout -out agent/mcp_auth/public.pem

# Copy public key to server
cp agent/mcp_auth/public.pem server/mcp_auth/public.pem

3. Start the system

docker-compose up --build

4. Pull the Llama model (first run only)

docker exec -it <ollama-container-id> ollama pull llama3.2:latest

5. Open the chat interface

Visit http://localhost:8000 in your browser and start chatting with the agent!

🧰 Tech Stack

📄 License

This project was developed as part of the Operating Systems Administration course, 2025.