Senior AI Engineer

Madfish; Remote; GBP 70,000 - 90,000; Full time

Job summary

A dynamic tech company in the United Kingdom is seeking an experienced AI Engineer to develop and support agentic AI systems for client projects. The role emphasizes hands-on engineering, involving building, deploying, and iterating AI applications that deliver real solutions. Candidates should have substantial experience in Python development, AI/LLM applications, and be adept with frameworks like LangChain and RAG systems, contributing to innovative solutions and collaborating effectively within a team.

Qualifications

• 4+ years of professional Python development with production systems.
• 2+ years building production AI/LLM applications.
• Expert-level Python engineering with clean, maintainable code.
• Deep LangChain/LangGraph experience in multi-agent systems.
• RAG implementation expertise with chunking strategies and embedding models.
• Vector database expertise with optimized queries and schemas.
• Production LLM integration experience with OpenAI, Anthropic, and Google Gemini.
• Backend API development using FastAPI or Flask in production.

Responsibilities

• Build agentic AI systems using LangChain or LangGraph.
• Implement and optimize RAG pipelines with vector databases.
• Integrate multiple LLM providers like OpenAI and Google Gemini.
• Design AI system architectures for new client projects.
• Conduct technical discovery with clients to understand requirements.
• Perform code reviews and knowledge sharing on AI best practices.

Skills

Python development

AI/LLM applications

LangChain/LangGraph

RAG implementation

Vector databases

Backend API development

SQL and database design

Tools

FastAPI

Flask

PGVector

Docker

Job description

We need an AI Engineer who can work autonomously on complex agentic AI systems while contributing to our growing AI practice. You’ll work directly on client projects involving LLM agents, RAG systems, and AI model integration - not just building prototypes, but production systems that scale.

This isn’t a research role. This is hands‑on engineering: building, deploying, iterating, and supporting AI applications that solve real business problems.

What You’ll Actually Do

Core Responsibilities (70% of time)

• Build agentic AI systems using LangChain, LangGraph, or similar frameworks
• Implement and optimize RAG pipelines with vector databases (PGVector, Pinecone, etc.)
• Integrate multiple LLM providers (OpenAI, Google Gemini, Anthropic Claude)
• Fine‑tune models when off‑the‑shelf solutions don’t meet requirements
• Develop Python backends (FastAPI/Flask) that power AI applications
• Write production‑quality code with tests, documentation, and proper error handling

Technical Ownership (20% of time)

• Design AI system architectures for new client projects
• Make build/buy decisions on AI tooling and infrastructure
• Conduct technical discovery with clients to understand requirements
• Estimate project complexity and technical feasibility

Team Collaboration (10% of time)

• Code reviews for junior AI engineers
• Knowledge sharing on AI patterns and best practices
• Client communication on technical approaches and trade‑offs

Our Current Tech Stack

AI/ML:

• LangChain, LangGraph for agentic systems
• OpenAI GPT‑4, Google Gemini, Anthropic Claude
• PGVector for embeddings and retrieval
• Fine‑tuning pipelines (OpenAI, Gemini)

Backend:

• Python 3.11+ (FastAPI primary, Flask acceptable)
• PostgreSQL with PGVector extension
• Google Cloud Run, Cloud Functions

Infrastructure:

• Google Cloud Platform (BigQuery, Cloud SQL, Cloud Run, Vertex AI)
• Firebase/Supabase for user management
• Docker for containerization

Frontend Integration:

• REST APIs consumed by React/TypeScript frontends
• Real‑time capabilities (WebSockets, Server‑Sent Events)

Development:

• Git/GitHub for version control
• Linear for project management
• Bolt.new for rapid prototyping (you won’t use this much)

Must‑Have Skills

Technical Requirements

• 4+ years of professional Python development - You’ve built production systems, not just scripts. You understand design patterns, testing strategies, and code that scales.
• 2+ years building production AI/LLM applications - Real systems serving real users, not just experiments or prototypes. You’ve handled model deployment, monitoring, and iteration based on production feedback.
• Expert‑level Python engineering - You write clean, maintainable, testable code. You can explain the difference between "staticmethod" and "classmethod" and actually care about it. You’ve debugged memory leaks, optimized performance bottlenecks, and know when to use async/await.
• Deep LangChain/LangGraph experience - You’ve built multi‑agent systems with complex orchestration. You understand the framework’s internals well enough to work around its limitations. You’ve debugged agent loops, optimized token usage, and handled error states gracefully.
• RAG implementation expertise - You’ve built RAG systems that actually work in production. You understand chunking strategies, embedding models, hybrid search, re‑ranking, and when RAG isn’t the right solution. You’ve tuned retrieval quality beyond the tutorial examples.
• Vector database expertise - PGVector, Pinecone, Weaviate, or equivalent. You’ve designed schemas, optimized queries, and handled millions of embeddings. You understand the trade‑offs between different distance metrics.
• Production LLM integration - OpenAI, Anthropic, Google Gemini in real applications. You’ve handled rate limiting, cost optimization, prompt engineering, context management, and fallback strategies. You know how to debug hallucinations and improve consistency.
• Backend API development - FastAPI or Flask in production. You’ve designed RESTful APIs, handled authentication, managed database connections, implemented error handling, and written API documentation. You understand HTTP status codes and when to use which one.
• SQL and database design - PostgreSQL specifically. You write efficient queries, design normalized schemas, use indexes appropriately, and understand when to denormalize. You’ve debugged slow queries and optimized database performance.

Working Style Requirements

• Self‑managed QA mindset - You write unit tests, integration tests, and think about edge cases before they become production bugs. You don’t need a QA engineer to tell you something doesn’t work.
• Pragmatic problem‑solver - You prefer "simplest thing that works" over perfect solutions. You know when to refactor and when to ship. You understand technical debt is a tool, not a failure.
• Comfortable with ambiguity - Client requirements evolve mid‑project. You adapt architecture without rebuilding from scratch. You ask clarifying questions but don’t wait for perfect specifications before starting.
• Strong technical communicator - You explain technical trade‑offs to non‑technical stakeholders. You write clear documentation. You give useful code review feedback. You can justify your architectural decisions.
• European timezone - Core hours overlap with UK (GMT/BST). You’re available for morning standups and client calls during UK business hours.