Basic info

Damian Jankov
About me

Full-stack engineer with 4 years of production experience in regulated domains (clinical trials, autonomous driving, medical ultrasound), working across C#/.NET and Python backends, React and Angular frontends and Azure infrastructure. Available as a B2B contractor for EU and US teams, remote from Košice, Slovakia (CET).

Education
M.Sc. Informatics2022 – 2024
Technical University of Košice
  • Thesis (grade A): generating test specifications and reports for ultrasound verification testing
B.Sc. Computer Networking2019 – 2022
Technical University of Košice
  • Thesis (grade A): OCB-AES authenticated encryption mode
Achievements & certifications
Claude Certified Architect – Foundations, AnthropicOct 2026
3rd place, Živé IT projekty competition  (see here)2022
B1 Deutsches Sprachdiplom2019

Job history

Where I've worked.

Volunteering

My tech stack

Technologies I've used professionally and in my own projects.
Languages
Backend
Frontend
Databases
Cloud & DevOps
Testing & AI

Personal projects

A few projects I have built in my free time. Each links to its source on GitHub.

A lightweight ORM for PostgreSQL built from scratch to understand what Entity Framework does under the hood. Generates tables and junction tables, translates LINQ expressions to SQL, and loads related entities recursively.

Tech Stack: C#, PostgreSQL

View on GitHub


DjOrm

A lightweight ORM for .NET that maps C# classes to PostgreSQL tables using custom attributes and a generic DbContext<T>.

Features

  • Auto-generates CREATE TABLE SQL from annotated C# entities
  • Junction table generation for entity relationships
  • Full CRUD operations via a single generic context
  • Translates simple LINQ expressions into SQL WHERE clauses
  • Recursive fetching of related objects via junction tables
  • Async throughout

Usage

1. Annotate your entities

[TableAttribute]
public class CarEntity
{
    [PrimaryKeyAttribute]
    public int Id { get; set; }
    public string Name { get; set; }
    public string Make { get; set; }

    [SecondaryKeyAttribute]
    public DriverEntity? Driver { get; set; }
}

2. Create tables and run queries

var db = new DatabaseConnector(connString);

// Auto-create tables from entity definitions
var entities = new TableEntitiesMaker(new TypeTranslator()).CreateObjectEntities();
await db.ExecuteCommands(new SqlCreateTablesTranslator(entities).TranslateEntitiesToCreateTables());

// CRUD
IDbContext<CarEntity> ctx = new DbContext<CarEntity>(db);

await ctx.InsertData(new CarEntity("Civic", "Honda", driver));
var all    = await ctx.GetData();
var hondas = await ctx.GetDataBy(x => x.Make == "Honda" && x.Name != "Accord");
await ctx.UpdateData(car);
await ctx.DeleteData(car);

LINQ expression support — GetDataBy walks the expression tree and translates binary expressions (==, !=, <, <=, >, >=, &&, ||) directly into parameterized SQL conditions.

3. Recursive fetching of related objects

Pass recursive: true (or isRecursive: true on DbContext) to automatically load related entities via their junction tables:

// Fetch all articles and populate their related TagEntity objects
var articles = await ctx.GetData(isRecursive: true);

// Same with a filter
var articles = await ctx.GetDataBy(x => x.Title == "Hello", isRecursive: true);

For each fetched object, DjOrm:

  1. Queries the junction table ({ParentType}{RelatedType}) using the parent's primary key.
  2. Looks up the related entity by its primary key.
  3. Assigns the result to the [SecondaryKey]-annotated property.

This works recursively — related objects that themselves have [SecondaryKey] properties are also populated.

Configuration

Connection string is loaded from a .env file:

HOST=localhost
PORT=5432
USERNAME=postgres
PASSWORD=postgres
DATABASE=testdb

A remote Model Context Protocol (MCP) server in C# that gives Claude tools to store and manage facts. Secured with OAuth 2.1 via WorkOS AuthKit and an email allowlist.

Tech Stack: C#, EF Core, PostgreSQL, Docker, WorkOS

View on GitHub


Bobi Facts MCP Server

A Model Context Protocol server (official C# SDK, ModelContextProtocol 2.0.0-preview.1) that stores facts about Bobi the cat. It runs as a Streamable HTTP server and persists to PostgreSQL via EF Core.

Tools

ToolArgumentsDescription
get_facts–Return all facts about Bobi.
insert_factcontent: stringAdd a new fact; returns the created fact.
delete_factid: intDelete a fact by id; returns if it hit.

Layout

src/BobMcp.Server/
  Models/Fact.cs            EF Core entity
  Dtos/                     Wire DTOs (FactDto, DeleteResultDto)
  Data/BobiDbContext.cs     EF Core DbContext
  Data/DesignTimeDbContextFactory.cs   For `dotnet ef`
  Migrations/               EF Core migrations (Npgsql)
  Services/IFactService.cs  Injectable service abstraction
  Services/FactService.cs   EF Core implementation (IDbContextFactory)
  Tools/FactTools.cs        [McpServerToolType] — thin handlers, delegate to service
  Program.cs                Host + DI + HTTP MCP wiring
src/BobMcp.Client/          A real MCP client (HTTP) used to test the server

The tool layer holds no logic — every tool maps arguments to an injected IFactService call, which is the only place that touches the database.

Configuration

Env varRequiredDefault
BOBI_DB_CONNECTIONyes–
BOBI_HTTP_URLnohttp://localhost:5111
AUTH_ISSUERyes–
MCP_RESOURCEyes–
ALLOWED_EMAILSyes–

Authentication is mandatory (see Authentication): if AUTH_ISSUER, MCP_RESOURCE, or ALLOWED_EMAILS is missing the server throws on startup and will not run — there is no unauthenticated mode.

BOBI_DB_CONNECTION is an Npgsql key/value string (not a postgresql:// URI):

Host=localhost;Port=5432;Username=postgres;Password=<pw>;Database=postgres;SSL Mode=Require;Trust Server Certificate=true

Build & run

dotnet build BobMcp.slnx -c Release

BOBI_DB_CONNECTION="Host=...;Channel Binding=Disable" \
AUTH_ISSUER="https://your-app.authkit.app" \
MCP_RESOURCE="http://localhost:5111/mcp" \
ALLOWED_EMAILS="you@gmail.com" \
  dotnet src/BobMcp.Server/bin/Release/net10.0/BobMcp.Server.dll

The auth vars are required — the server throws on startup without them. See Authentication.

The MCP endpoint is http://localhost:5111/mcp. The server applies EF Core migrations on startup.

Test it (acts as an MCP client)

dotnet src/BobMcp.Client/bin/Release/net10.0/BobMcp.Client.dll          # localhost:5111
dotnet src/BobMcp.Client/bin/Release/net10.0/BobMcp.Client.dll https://host/mcp

Or with curl:

curl -i -X POST http://localhost:5111/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

Migrations

dotnet ef migrations add <Name> --project src/BobMcp.Server

Authentication

The server is an OAuth 2.1 resource server, and auth is required — it refuses to start unless AUTH_ISSUER, MCP_RESOURCE, and ALLOWED_EMAILS are all set. It never shows a login page itself — it validates a JWT access token on every /mcp call and only lets through tokens whose email claim is in ALLOWED_EMAILS. The actual "sign in with Google" flow is run by WorkOS AuthKit, which acts as the OAuth authorization server. claude.ai (the MCP client) drives the whole flow: it discovers AuthKit from /.well-known/oauth-protected-resource, registers itself (DCR), sends you to Google to log in, then retries with Authorization: Bearer <token>.

claude.ai ──initialize──▶ /mcp ──401 + WWW-Authenticate──▶ claude.ai
claude.ai ──discovers──▶ WorkOS AuthKit ──Google login──▶ access token (aud = MCP_RESOURCE)
claude.ai ──Bearer token──▶ /mcp ──validate JWT + email allowlist──▶ tools

Why AuthKit and not Google directly: Google's OAuth doesn't support Dynamic Client Registration and won't scope tokens to this server, both of which MCP clients need.

The wiring lives in Auth/AuthenticationExtensions.cs: AddJwtBearer validates the token, .AddMcp(...) serves the resource metadata, and an authorization policy enforces the email allowlist.

One-time WorkOS AuthKit setup

  1. Create a WorkOS account and an AuthKit application (free tier is enough).
  2. Enable Google login: WorkOS Dashboard → Authentication → add Google OAuth as a sign-in method.
  3. Surface the email claim: Authentication → Sessions → Configure JWT Template, add "email": "{{ user.email }}" so the access token carries the email claim the allowlist checks.
  4. Enable Dynamic Client Registration: Applications / OAuth → turn on DCR (lets claude.ai register itself).
  5. Add a Resource Indicator equal to your public MCP URL, e.g. https://<host>/mcp. This becomes the token's aud. (Without it AuthKit uses a default environment-scoped aud, which won't match MCP_RESOURCE.)
  6. Copy your AuthKit domain (e.g. https://your-app.authkit.app) — that's AUTH_ISSUER.

Env vars

AUTH_ISSUER=https://your-app.authkit.app   # AuthKit domain (the OAuth issuer)
MCP_RESOURCE=https://<host>/mcp            # must match the AuthKit Resource Indicator + the URL you add in claude.ai
ALLOWED_EMAILS=you@gmail.com               # comma-separated allowlist

Hosting for claude.ai

claude.ai connects to remote MCP servers over Streamable HTTP. To expose this one:

  1. Run it pointed at your PostgreSQL DB, with the Authentication env vars set.
  2. Put it behind public HTTPS (reverse proxy or a tunnel such as Cloudflare Tunnel / ngrok) — claude.ai requires https://. Make MCP_RESOURCE match this public /mcp URL.
  3. In claude.ai → Settings → Connectors, add https://<host>/mcp. claude.ai will walk you through the Google sign-in on first connect.

A retrieval-augmented generation pipeline in C# that extracts text from PDFs, creates embeddings with a local Ollama model, and stores them in Qdrant for semantic search.

Tech Stack: C#, .NET 9, Ollama, Qdrant, PdfPig, Docker

View on GitHub


RAG (Retrieval-Augmented Generation) - C# Implementation

A C# implementation of a Retrieval-Augmented Generation (RAG) system that processes PDF documents and enables intelligent question-answering using local AI models.

Overview

This RAG implementation allows you to ask questions about PDF documents by combining semantic search with large language models. The system extracts text from PDFs, converts it into semantic vectors, stores them in a vector database, and retrieves relevant context to generate accurate answers.

Architecture

The system uses the following components:

  • Qdrant: Vector database for storing and searching semantic embeddings
  • Ollama with Phi3 model: Local LLM for generating embeddings and completions
  • PdfPig: PDF text extraction library
  • .NET 9.0: Runtime environment

How It Works

  1. PDF Processing: Extract text content from PDF documents
  2. Text Chunking: Split the text into manageable chunks
  3. Overlay Chunking: Create overlapping chunks to maintain context continuity
  4. Semantic Vectorization: Convert each chunk into semantic vectors using Ollama's Phi3 model
  5. Vector Storage: Store all vectors in Qdrant vector database
  6. Query Processing: Convert user queries into semantic vectors
  7. Similarity Search: Use Qdrant to find the most relevant chunks via semantic search
  8. Context Augmentation: Compose a final prompt with retrieved context
  9. Answer Generation: Generate accurate answers using the LLM with relevant context

Prerequisites

  • Docker with GPU passthrough support enabled
  • NVIDIA GPU (required for Ollama to run efficiently)
  • .NET 9.0 SDK or later

Docker GPU Setup

Ensure Docker has access to your GPU. You need:

  • NVIDIA Container Toolkit installed
  • Docker configured with --gpus=all flag support

An educational AES-128 implementation in C#, built to understand the algorithm behind my bachelor's thesis on authenticated encryption. Verified against official NIST test vectors and benchmarked against .NET's native AES implementation.

Tech Stack: C#, .NET 9, BenchmarkDotNet

View on GitHub


AES Implementation in C#

A simple, educational implementation of the Advanced Encryption Standard (AES) algorithm in C#. This project demonstrates the core AES encryption and decryption processes with a focus on clarity and learning.

Educational Purpose Only: This implementation is intended for learning and educational purposes. Do NOT use this in production environments or for securing sensitive data.

Quick Start

Prerequisites

Supported Features

  • ✅ AES-128 encryption and decryption
  • ✅ Single block operations (16 bytes)
  • ✅ Row-based state representation
  • ✅ NIST SP 800-38A test vector compliance

Limitations

  • ❌ Only supports 128-bit keys
  • ❌ Single block only (no chaining modes like ECB, CBC)
  • ❌ No initialization vectors (IV)
  • ❌ Not optimized for production use

Performance Benchmarks

Latest benchmark results on Ubuntu 24.04.3 LTS with Intel Core i5-12450H:

MethodMeanErrorStdDevRatio
Custom AES Encrypt4,048.8 ns74.34 ns62.07 ns~4.9x
Custom AES Decrypt7,394.6 ns31.49 ns29.46 ns~8.7x
.NET AES Encrypt832.0 ns3.82 ns3.58 ns1.0x
.NET AES Decrypt847.2 ns5.56 ns4.64 ns1.0x

Testing

The implementation is thoroughly tested against NIST Special Publication 800-38A and FIPS 197 test vectors:

dotnet test --verbosity normal

All tests validate:

  • Correct encryption of known plaintext/key pairs
  • Proper decryption back to original plaintext
  • Compliance with NIST standards

Learning Resources

License

This project is for educational purposes only. Please refer to the license file for details.

Contributing

This is an educational project. Feel free to fork and experiment, but remember this is not intended for production use.

Contact me

Have a question or want to get in touch? Fill in the form below and your Gmail email client will open with the message ready to send.