Applire

Open-Source Career Intelligence Platform for the DACH Market

Transform hours of CV tailoring into seconds. Upload your CVs, paste a job description, and let AI guide you through an intelligent interview to create perfectly matched application documents.

🚀 Quick Start • 📖 Documentation • 💬 Community • 🐛 Report Bug

💡 What is Applire?

Applire is an open-source AI platform that combines deep career intelligence with DACH-specific cultural expertise to automate high-quality CV tailoring.

Built for all job seekers in the DACH market, with unmatched depth in regulated industries (Pharma, GxP, Medtech) — a specialization that proves our precision for every user.

Unlike generic CV builders, Applire:

🧠 Learns from you: Builds a persistent Master Profile that gets smarter with every CV you upload
💬 Interviews you intelligently: Asks targeted questions to fill gaps between your experience and job requirements
✨ Tailors with precision: Generates culturally appropriate CVs optimized for DACH recruiters and ATS systems
🤖 Agent-first design: Accessible to AI assistants via the Model Context Protocol (MCP)
🔒 Privacy by design: GDPR-compliant, self-hosted, full data sovereignty

In 3 simple steps:

📄 Upload 2-4 versions of your CV
🔗 Paste the job description
💬 Answer a few intelligent questions → ✨ Get a perfectly tailored CV

👥 Who is Applire for?

Applire serves diverse personas across the DACH job market:

💼 Marcus - The Expert

Experienced professional with deep domain expertise who needs precision tailoring for demanding roles. Values efficiency and quality over hand-holding.

🌍 Priya - The Relocator

International candidate moving to DACH who needs cultural "translation" of their career history to meet local CV conventions and recruiter expectations.

✏️ Felix - The Finetuner

Any user who wants surgical, section-level control over their CV. Trusts AI to draft but wants to fine-tune the output to sound authentic and personal.

🤖 Kaile - The AI Agent

AI assistant (Claude, ChatGPT, custom agents) calling Applire on behalf of human users via MCP or REST API for seamless career intelligence integration.

✨ Key Features

🧠 Intelligent Master Profile

Multi-CV Consolidation: Upload multiple CVs and automatically merge them into a rich, conflict-aware Master Profile
Additive Enrichment: Every CV upload, interview session, and edit enriches your profile — it never overwrites, only accumulates
Source Tracking: Full audit trail of where every piece of information came from
Conflict Resolution: Smart detection of factual contradictions (dates, degrees) with user-controlled resolution

🎯 Job-First Analysis & Gap Detection

Deep JD Analysis: Extracts requirements, skills, cultural signals, and industry context from job descriptions
Transparent Gap Scoring: 0-100% match score with detailed explanations of what's missing
Categorized Gaps:
- Category A (Hard blockers): Must-have requirements you don't meet
- Category B (Confirmation needed): You likely have this, but it's not stated clearly
- Category C (Exploratory): Soft requirements worth discussing

💬 Conversational Interview Orchestrator

Two Modes:
- Targeted Mode (for experienced users): Focuses on filling specific gaps identified in your profile
- Guided Mode (for new users): Systematically builds your profile section by section
Stateful Backend: Pause and resume anytime — your progress is saved server-side
Smart Completion: Automatically detects when you're done or when all gaps are resolved
Profile Updates: Every answer enriches your Master Profile in real-time

📄 CV Generation & Fine-Tuning

ATS-Optimized PDFs: Generated via Playwright/Chromium with CSS-based themes
Live Browser Preview: See exactly what your CV will look like before downloading
Section-Level Editing: Fine-tune individual sections (introduction, positions, skills) with live re-rendering
Dual Save Path: Save edits to your Master Profile (permanent) or just to this CV (one-time)
AI-Assisted Editing: Optional "Let Kaile help" for targeted gap completion within the editor
Cover Letter Generation: AI-powered cover letter creation based on JD and Master Profile
Cultural Adaptation: Automatic detection and formatting for German, Austrian, and Swiss CV conventions

🗺️ DACH Cultural Intelligence

Market-Specific Formatting: Lebenslauf vs. international CV formats
Cultural Signal Detection: Identifies when a CV needs adaptation (e.g., Indian → German pharma standards)
Multilingual Support: German and English UI; French and Spanish planned
Regulatory Industry Depth: Specialized knowledge for Pharma, GxP, Medtech roles

🔒 Privacy & GDPR Compliance

Privacy by Design (GDPR Art. 25): Minimal data collection, encryption at rest
Automated Retention: Daily cron job enforces TTLs:
- Uploaded files: 7 days
- Interview sessions: 30 days
- Generated CVs: 90 days (human) / 24 hours (agent)
Right to Erasure (GDPR Art. 17): One-click full data deletion
Self-Hosted: Your data never leaves your infrastructure

🤖 Built for the AI Agent Era

Applire is the first career platform optimized for AI agents as customers:

Model Context Protocol (MCP)

Seamless Integration: First-class support for Claude Desktop, ChatGPT, Cursor, and custom AI agents
Stateful Sessions: Agents can pause, resume, and recover from interruptions
Flow Orchestrator: Guides agents through the correct sequence (JD analysis → CV import → gap analysis → interview → generation)
Async Generation: Non-blocking CV generation with polling-based status checks

REST API

Full HTTP API: Programmatic access for remote integrations
OpenAPI Documentation: Interactive Swagger UI at /docs

Agent Workflow Example

# Start MCP server (stdio transport)
python -m applire.mcp

# Agent calls:
1. start_flow() → flow_id
2. analyze_jd(text="Senior Python Engineer...") → job_id
3. analyze_gaps(job_id) → gap_report
4. run_interview(session_id, message="I have 5 years...") → next_question
5. generate_cv(job_id) → cv_id (async)
6. get_cv_status(cv_id) → {status: "ready", pdf_url: "..."}

🏗️ Architecture & Tech Stack

Backend

Python 3.12+: Modern async Python with type hints
FastAPI: High-performance async web framework
PostgreSQL 16: JSONB for flexible Master Profile schema
Pydantic: Type-safe data validation and serialization
SQLAlchemy 2.0: Async ORM with full type support
Alembic: Database migrations

Frontend

Next.js 15: React framework with App Router
TypeScript: Type-safe JavaScript
ShadCN/UI: Accessible component library
Tailwind CSS v4: Utility-first styling

AI/ML

OpenRouter (default): Multi-model gateway giving access to Mistral, Claude, and others with a single API key
LLM Provider Abstraction: Pluggable backends for Mistral, OpenAI, Ollama (self-hosted)
Custom State Machine: Async interview orchestrator (no LangGraph dependency)
Playwright: Headless Chromium for PDF generation

Infrastructure

Docker & Docker Compose: Containerized deployment
PostgreSQL 16: Primary database with JSONB support
Retention Worker: Daily cron for GDPR TTL enforcement
GitHub Actions: CI/CD pipeline with pytest and Playwright E2E tests

Agent Integration

Model Context Protocol (MCP): stdio transport for local AI agents
REST API: Full HTTP API for remote integrations
Flow Orchestrator: State machine for multi-step agent workflows
Session Recovery: Agents can resume interrupted sessions via flow_id

🚀 Installation

Prerequisites

Docker & Docker Compose
LLM API Key: Mistral AI (default), OpenRouter, OpenAI, or Ollama (local/free)

Self-hosting (no clone required)

# 1. Download the two required files
curl -O https://raw.githubusercontent.com/tobias-rosenbaum/Applire/main/docker-compose.yml
curl -O https://raw.githubusercontent.com/tobias-rosenbaum/Applire/main/.env.example

# 2. Configure your environment
cp .env.example .env
# Edit .env: set LLM_PROVIDER and the matching API key (see Configuration below)

# 3. Start all services
docker compose up -d

# 4. Run database migrations (first run only)
docker compose exec backend alembic upgrade head

Access the application:

Frontend: http://localhost:3000
API docs: http://localhost:8001/docs

To update to the latest release:

docker compose pull && docker compose up -d

Contributing? See CONTRIBUTING.md for the build-from-source developer setup.

⚙️ Configuration

Environment Variables

Copy .env.example to .env and configure:

# Database
DATABASE_URL=postgresql+asyncpg://applire:applire@postgres:5432/applire

# LLM Provider — choose one: mistral | openrouter | openai | ollama
LLM_PROVIDER=mistral

# Mistral AI — EU-hosted, GDPR-native, default
MISTRAL_API_KEY=your-mistral-api-key-here
MISTRAL_MODEL=mistral-medium-latest

# OpenRouter — multi-model gateway, recommended alternative
# Get a key at https://openrouter.ai/keys
OPENROUTER_API_KEY=your-openrouter-api-key-here
OPENROUTER_MODEL=mistralai/mistral-medium-3

# OpenAI or any OpenAI-compatible server (e.g. LM Studio)
OPENAI_API_KEY=your-openai-api-key-here
#OPENAI_MODEL=gpt-4o
#OPENAI_BASE_URL=http://host.docker.internal:1234/v1

# Ollama — fully offline (docker compose --profile ollama up)
OLLAMA_BASE_URL=http://ollama:11434
OLLAMA_MODEL=llama3.2

# LLM timeout in seconds (raise for reasoning models)
LLM_TIMEOUT=180

# Auth (none for Community Edition single-user mode)
AUTH_PROVIDER=none

# CORS — comma-separated list of allowed origins
CORS_ORIGINS=http://localhost:3000,http://localhost:3001

# nginx proxy timeout — must be greater than LLM_TIMEOUT
#NGINX_PROXY_TIMEOUT=300

# Frontend API URL
# docker compose: leave empty — nginx at :80 routes /api/* to the backend
# standalone dev: set to http://localhost:8001
#NEXT_PUBLIC_API_URL=http://localhost:8001

LLM Provider Options

Applire supports multiple LLM backends via a pluggable abstraction layer:

Provider	Configuration	Use Case
OpenRouter (default)	`LLM_PROVIDER=openrouter` `OPENROUTER_API_KEY=...`	Multi-model gateway; access Mistral, Claude, and others with one key
Mistral AI	`LLM_PROVIDER=mistral` `MISTRAL_API_KEY=...`	EU-hosted, GDPR-native, strong German proficiency
OpenAI	`LLM_PROVIDER=openai` `OPENAI_API_KEY=...`	High quality, widely available; also supports LM Studio via `OPENAI_BASE_URL`
Ollama (local)	`LLM_PROVIDER=ollama` `OLLAMA_BASE_URL=http://localhost:11434`	Fully offline, no API costs, privacy-first

📖 API Documentation

REST API

Full OpenAPI documentation available at http://localhost:8001/docs (Swagger UI).

Core Endpoints

# Job Description Analysis
POST /api/job/analyze
{
  "text": "Senior Software Engineer role...",
  "url": "https://example.com/job"  # Optional
}

# CV Upload & Profile Enrichment
POST /api/profile/upload
Content-Type: multipart/form-data
files: [cv1.pdf, cv2.pdf]

# Gap Analysis
POST /api/gap/analyze
{ "job_id": "uuid" }

# Start Interview Session
POST /api/session
{ "job_id": "uuid", "mode": "targeted" }

# Send Interview Message
POST /api/session/{session_id}/message
{ "message": "I have 5 years of experience with Python..." }

# Generate CV
POST /api/cv/generate
{ "job_id": "uuid", "theme": "classic_german" }

# Check CV Generation Status
GET /api/cv/{cv_id}/status
# Returns: { "status": "pending" | "ready" | "failed" }

# Download CV
GET /api/cv/{cv_id}/pdf

Model Context Protocol (MCP)

# Start MCP server (stdio transport)
python -m applire.mcp

MCP Tools

Tool	Description
`start_flow(job_id?)`	Create or resume a flow session
`analyze_jd(text?, url?)`	Analyze a job description
`analyze_gaps(job_id)`	Detect gaps between profile and JD
`run_interview(session_id, message)`	Send a message in an interview session
`generate_cv(job_id, options?)`	Initiate async CV generation
`get_cv_status(cv_id)`	Poll CV generation status
`advance_flow(flow_id, step, artifact_id?)`	Advance to next step in flow
`get_flow_state(flow_id)`	Get current flow state and available actions

MCP Resources

profile://current — User's Master Profile
job://{job_id} — Job analysis
cv://{cv_id} — Generated CV
flow://{flow_id} — Flow session state

🧪 Testing

Backend Tests

# Run all tests
pytest

# Run with coverage (enforces ≥75% threshold)
pytest --cov=applire --cov-fail-under=75

# Generate HTML coverage report
pytest --cov=applire --cov-report=html

Frontend Tests

# Run unit tests
npm test

# Run E2E tests (Playwright)
npm run test:e2e

# Run E2E tests in UI mode
npm run test:e2e:ui

CI/CD Pipeline

GitHub Actions runs:

Backend unit tests (pytest, ≥75% coverage)
Backend integration tests (Docker stack)
E2E tests (Playwright, Chromium + Firefox)

All tiers must pass before merge.

📁 Project Structure

Applire/
├── backend/
│   ├── applire/
│   │   ├── main.py              # FastAPI application entry point
│   │   ├── models/              # SQLAlchemy ORM models
│   │   ├── schemas/             # Pydantic request/response schemas
│   │   ├── routers/             # FastAPI route handlers
│   │   ├── services/            # Business logic layer
│   │   │   ├── interview/       # Interview Orchestrator (state machine)
│   │   │   ├── flow/            # Flow Orchestrator
│   │   │   ├── profile/         # Master Profile merge logic
│   │   │   ├── cv/              # CV generation & section editing
│   │   │   └── gap/             # Gap analysis
│   │   ├── providers/           # LLM, Auth, Storage abstractions
│   │   ├── mcp/                 # Model Context Protocol server
│   │   ├── retention/           # GDPR retention worker
│   │   └── templates/           # Jinja2 CV templates
│   ├── alembic/                 # Database migrations
│   ├── tests/                   # Pytest test suite
│   └── requirements.txt
├── frontend/
│   ├── app/                     # Next.js App Router pages
│   ├── components/              # React components
│   ├── lib/                     # Utilities and API clients
│   └── public/
├── docs/
│   ├── TESTING.md               # Testing strategy and commands
│   ├── CI_CD_GUIDE.md           # CI/CD pipeline documentation
│   └── TRACEABILITY.md          # Requirements traceability
├── tests/                       # Integration and E2E tests
├── docker-compose.yml
├── .env.example
└── README.md

🗺️ Roadmap

✅ Current Release (v0.31.0-beta)

⏳ Next Up

Core Experience Improvements

Gap Interview Refinement: Enhanced question quality and relevance
Additional CV Layouts: Expanding template library

Market Expansion

European Country Support: Gradual rollout beyond DACH (France, Italy, Spain, Portugal, Poland) with localized formats and language support

Developer Experience

MCP Marketplace Listing: Distribution via Anthropic, OpenAI, and Cursor marketplaces

🔭 Future Vision

Mock Interview Preparation: AI-powered practice sessions with role-specific questions
Career Path Advisory: Skill gap analysis and training recommendations
Job Search & Recommendation: Curated job suggestions based on Master Profile
Mobile App: iOS and Android native applications

🤝 Contributing

We welcome contributions! Please follow these steps:

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Commit your changes: git commit -m 'feat: add amazing feature'
Push to the branch: git push origin feature/amazing-feature
Open a Pull Request

Development Guidelines

Follow PEP 8 for Python code (enforced by black)
Use TypeScript for all frontend code (strict mode, no any)
Write tests for new features (≥75% backend coverage)
Keep commits atomic and use Conventional Commits
All schema changes go through Alembic migrations — never raw DDL

Code Style

# Backend: Format with Black
black .

# Frontend: Lint with ESLint
npm run lint

Contributor License Agreement

By submitting a pull request you agree to the Applire CLA. This allows us to maintain the open-core model while keeping the Community Edition fully open-source. See CONTRIBUTING.md for details.

💬 Community & Support

Get Help

📖 Documentation — Testing, CI/CD, and architecture guides
🐛 GitHub Issues — Report bugs and request features
💬 GitHub Discussions — Ask questions and share ideas

📄 License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) — see the LICENSE file for details.

Why AGPL?

We chose AGPL to ensure that:

✅ The software remains free and open source — Always accessible to everyone
✅ Modifications must be shared — Even when used as a service (SaaS)
✅ The community benefits — All improvements flow back to the project
✅ Your privacy is protected — Full transparency in how your data is processed
✅ No vendor lock-in — You control your data and infrastructure

Commercial Licensing

For organizations that cannot comply with AGPL requirements (e.g., proprietary SaaS offerings), commercial licenses are available. Contact applire@posteo.com for details.

🙏 Acknowledgments

Mistral AI for EU-hosted LLM infrastructure
FastAPI and Next.js communities
All contributors and early adopters
DACH industry professionals who provided domain expertise
The open-source community for inspiration and tools

📬 Contact

Website: applire.de (coming soon)
Email: applire@posteo.com
Issues: GitHub Issues
Security: applire@posteo.com (see SECURITY.md)

Built with ❤️ for job seekers in the DACH market

Open-source career intelligence. Privacy-first. Agent-ready.

⭐ Star us on GitHub

Name		Name	Last commit message	Last commit date
Latest commit History 82 Commits
.github		.github
backend		backend
docs		docs
frontend		frontend
nginx		nginx
scripts		scripts
tests		tests
.env.ci		.env.ci
.env.example		.env.example
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CLA.md		CLA.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
docker-compose.ci.yml		docker-compose.ci.yml
docker-compose.override.yml		docker-compose.override.yml
docker-compose.yml		docker-compose.yml
package-lock.json		package-lock.json
package.json		package.json
playwright.config.pq.ts		playwright.config.pq.ts
playwright.config.ts		playwright.config.ts
requirements-dev.txt		requirements-dev.txt
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

Applire

💡 What is Applire?

👥 Who is Applire for?

💼 Marcus - The Expert

🌍 Priya - The Relocator

✏️ Felix - The Finetuner

🤖 Kaile - The AI Agent

✨ Key Features

🧠 Intelligent Master Profile

🎯 Job-First Analysis & Gap Detection

💬 Conversational Interview Orchestrator

📄 CV Generation & Fine-Tuning

🗺️ DACH Cultural Intelligence

🔒 Privacy & GDPR Compliance

🤖 Built for the AI Agent Era

Model Context Protocol (MCP)

REST API

Agent Workflow Example

🏗️ Architecture & Tech Stack

Backend

Frontend

AI/ML

Infrastructure

Agent Integration

🚀 Installation

Prerequisites

Self-hosting (no clone required)

⚙️ Configuration

Environment Variables

LLM Provider Options

📖 API Documentation

REST API

Core Endpoints

Model Context Protocol (MCP)

MCP Tools

MCP Resources

🧪 Testing

Backend Tests

Frontend Tests

CI/CD Pipeline

📁 Project Structure

🗺️ Roadmap

✅ Current Release (v0.31.0-beta)

⏳ Next Up

🔭 Future Vision

🤝 Contributing

Development Guidelines

Code Style

Contributor License Agreement

💬 Community & Support

Get Help

📄 License

Why AGPL?

Commercial Licensing

🙏 Acknowledgments

📬 Contact

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

Packages