Jobs in Newcastle, United Kingdom

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.

• 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

• 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

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

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

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

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

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

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

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.

• 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.