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).
Contract for a US clinical-trial data platform used worldwide; international team, regulated environment.
Autonomous-driving data platform and internal tooling for Audi.
Internal web and desktop apps for ultrasound verification testing.
Non-profit civic platform in North Macedonia for reporting pollution and organising clean-ups.
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
A lightweight ORM for .NET that maps C# classes to PostgreSQL tables using custom attributes and a generic DbContext<T>.
CREATE TABLE SQL from annotated C# entitiesWHERE clauses1. 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:
{ParentType}{RelatedType}) using the parent's primary key.[SecondaryKey]-annotated property.This works recursively — related objects that themselves have [SecondaryKey] properties are also populated.
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
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.
| Tool | Arguments | Description |
|---|---|---|
get_facts | – | Return all facts about Bobi. |
insert_fact | content: string | Add a new fact; returns the created fact. |
delete_fact | id: int | Delete a fact by id; returns if it hit. |
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.
| Env var | Required | Default |
|---|---|---|
BOBI_DB_CONNECTION | yes | – |
BOBI_HTTP_URL | no | http://localhost:5111 |
AUTH_ISSUER | yes | – |
MCP_RESOURCE | yes | – |
ALLOWED_EMAILS | yes | – |
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
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.
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"}}}'
dotnet ef migrations add <Name> --project src/BobMcp.Server
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.
"email": "{{ user.email }}" so the access token carries the email claim the
allowlist checks.https://<host>/mcp. This becomes the token's aud. (Without it AuthKit uses a
default environment-scoped aud, which won't match MCP_RESOURCE.)https://your-app.authkit.app) — that's AUTH_ISSUER.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
claude.ai connects to remote MCP servers over Streamable HTTP. To expose this one:
https://. Make MCP_RESOURCE match this public /mcp URL.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
A C# implementation of a Retrieval-Augmented Generation (RAG) system that processes PDF documents and enables intelligent question-answering using local AI models.
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.
The system uses the following components:
Ensure Docker has access to your GPU. You need:
--gpus=all flag supportAn 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
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.
Latest benchmark results on Ubuntu 24.04.3 LTS with Intel Core i5-12450H:
| Method | Mean | Error | StdDev | Ratio |
|---|---|---|---|---|
| Custom AES Encrypt | 4,048.8 ns | 74.34 ns | 62.07 ns | ~4.9x |
| Custom AES Decrypt | 7,394.6 ns | 31.49 ns | 29.46 ns | ~8.7x |
| .NET AES Encrypt | 832.0 ns | 3.82 ns | 3.58 ns | 1.0x |
| .NET AES Decrypt | 847.2 ns | 5.56 ns | 4.64 ns | 1.0x |
The implementation is thoroughly tested against NIST Special Publication 800-38A and FIPS 197 test vectors:
dotnet test --verbosity normal
All tests validate:
This project is for educational purposes only. Please refer to the license file for details.
This is an educational project. Feel free to fork and experiment, but remember this is not intended for production use.