agentic-architectures
This project is the hub of a series on agentic AI: a framework-free Python catalog that implements every major agent architecture side by side on one tiny runtime — prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer (generator-critic), ReAct, plan-and-execute, ReWOO, reflection, tree search, supervisor, swarm handoffs, multi-agent debate, human-in-the-loop, memory and agentic RAG. A decision guide and a benchmark compare LLM calls and latency per pattern, and every pattern links to a repository that implements it in LangGraph, Google ADK, CrewAI, LangChain or LangSmith.

langgraph-parallel-agents
This project is a LangGraph showcase of the parallelization / map-reduce agent pattern: a planner fans out with the Send API to tool-using researcher subgraphs over a local corpus, merges their findings through a reducer and writes a cited answer, with sectioning and majority-voting variants. Each branch has its own retries, timeouts and failure isolation, and a benchmark measures an 8x speed-up at 16 branches.

langgraph-plan-and-execute
This project implements the planning agent architecture in LangGraph three ways: a planner writes a validated Pydantic plan that a ReAct executor runs while a replanner edits it or inserts recovery steps under a hard budget; ReWOO (two model calls per task) and LLMCompiler-lite (parallel DAG waves) run side by side, and a human approves or edits the plan through interrupt() with a SQLite checkpointer.

langgraph-reflection-agent
This project implements the reflection agent architecture in LangGraph three ways: a rubric-critic draft-critique-revise loop, Reflexion with verbal lessons kept across attempts, and LATS-lite tree search with backpropagated values. Model-written code is graded by unit tests in a hardened subprocess sandbox, and convergence plots come from real runs.

langgraph-short-long-term-memory
This project is a personal-assistant agent in LangGraph that teaches short-term vs long-term agent memory: thread-scoped history with a SQLite checkpointer, token-budget trimming, running summaries and time-travel replay, versus per-user facts, episodic recall and procedural rules shared across threads with semantic search on local embeddings and a one-call "forget me".

adk-sequential-pipeline
This project is a Google Agent Development Kit (ADK) showcase of the sequential pipeline and agent-critic architecture: a SequentialAgent runs a researcher, an outliner, a writer-critic LoopAgent, a fact-checker and an editor to turn a topic and local sources into a reviewed, cited post, with guardrail callbacks and ADK's own evaluation tooling.

adk-vertex-memory-bank
This project is a Google ADK travel concierge with long-term memory built for Vertex AI Agent Engine Memory Bank. One environment variable switches between Memory Bank and a free local look-alike on SQLite with LLM fact extraction, consolidation, per-user scopes and TTL, and one contract test suite proves both backends behave the same.

adk-vertex-vector-search
This project is an agentic RAG agent in Google ADK on Vertex AI Vector Search: it rewrites questions, searches with metadata restricts, checks whether the context suffices and searches again within a hop limit, and answers with verified citations or refuses. A free FAISS + BM25 look-alike passes the same contract suite as the Vertex adapter.

crewai-hierarchical-planning
This project implements the hierarchical (supervisor) multi-agent architecture with planning in CrewAI: a manager agent plans and delegates a product launch to specialist agents with sandboxed tools and a QA critic, and a CrewAI Flow routes simple requests to a single agent, asks a human for feedback and validates the structured output with guardrails.

langchain-tag-agent
This project implements Table-Augmented Generation (TAG) in LangChain: questions that need both database computation and semantic reasoning run as a guarded read-only SQL query, row-wise LLM operators and exact aggregation, then an answer generated from the final table. A sqlglot guard and a SQLite authorizer reject every query in a 51-case adversarial suite.

langsmith-agent-evals
This project is offline evaluation and observability for a LangGraph customer-support agent with the LangSmith SDK: correctness, tool-call trajectory and LLM-as-judge critic evaluators on a local model, pairwise A/B of prompt versions, JSONL traces, an HTML report and a CI regression gate, with zero calls to LangSmith cloud.

ui-review-agent
This project is a browser agent that reviews web UIs like a QA engineer. It crawls a site in sandboxed headless Chromium with Playwright, screenshots every page on mobile, tablet and desktop in light and dark mode, and runs a ReAct loop of model-free checks (overflow, overlapping text, tap targets, broken links, axe-core accessibility, visual regression) before an optional local vision model on Ollama critiques the screenshots. It fails CI with HTML, JSON and JUnit reports and only ever sends GET requests.

local-rag-ollama
This project is a fully local RAG application that answers questions about folders of Markdown, HTML, PDF and text with cited answers from open-weight models on Ollama, so documents never leave the machine. Hybrid retrieval fuses SQLite FTS5 BM25 and sqlite-vec vectors with reciprocal rank fusion and an optional local cross-encoder reranker, and a public-domain benchmark measures recall@k, MRR, faithfulness and latency.

agent-model-router
This project is a local proxy for coding agents such as Claude Code that picks the model and reasoning effort for every request, inspired by jev-router. An explainable classifier sends each turn to the cheapest model that clears the quality bar, keeps conversations sticky for warm prompt caches and escalates on errors, while translating Anthropic Messages and OpenAI Chat Completions both ways with streaming and tool calls.

serverless-mcp-aws
This project is a Python library that runs Model Context Protocol (MCP) servers on AWS Lambda behind API Gateway in stateless Streamable HTTP mode. It verifies JWT bearer tokens with an algorithm allowlist and cached JWKS, maps each token's scopes to the tools it may call, and ships an AWS CDK construct with least-privilege IAM and throttling, all tested offline with local keys, moto and the official MCP client.

pytest-llm-evals
This project is a pytest plugin that turns LLM and agent evaluation into ordinary tests. Golden YAML/JSONL datasets become parametrized cases, scorers range from ROUGE/BLEU and JSON Schema to tool-call trajectories, and an injection-resistant LLM-as-judge with position-bias mitigation grades the rest. Cost, token and latency budgets, regression baselines and pass@k fail the run like any other test, and cached responses make re-runs free and deterministic.

s3-agent-memory
This project is a long-term memory library for AI agents that stores typed memories (facts, events, instructions) as plain JSON objects in any S3-compatible bucket, with no database or vector service. Concurrent agents write safely through S3 conditional requests, recall blends BM25 and optional local embeddings with recency and importance, and it ships an MCP server, a LangGraph store and a CLI.

repo-graph-mcp
This project is an MCP server that turns a codebase into a deterministic AST knowledge graph (Python via ast, TypeScript via tree-sitter) with no embeddings, vector store or LLM, indexed incrementally into SQLite with full-text search. Coding agents ask for callers, blast radius, covering tests and call paths instead of grepping, using about 20x fewer tokens in an offline benchmark.

agent-lint
This project is a ratcheting lint gate for code written by AI coding agents. It runs a project's own linters (ruff, mypy, bandit, eslint, semgrep, shellcheck) against a committed baseline that can only shrink, and catches the shortcuts agents take to get a green build: new suppression comments, skipped or emptied tests and loosened linter configuration. It ships as Claude Code hooks, a pre-commit hook and a GitHub Action with PR comments and SARIF output.

langchain-virtual-assistant
This project delivers an AI-powered virtual assistant built with LangChain and RAG, enabling context-aware conversations and document analysis powered by OpenAI's GPT models. It allows users to query documents and hold coherent, context-rich dialogues with intelligent retrieval and generation capabilities.

llm-react-api
This project is a React-based single page application, styled using TailwindCSS, that allows users to explore and analyze character interactions in Project Gutenberg e-books. The application leverages a Language Learning Model (LLM) to process the text of e-books and visually represent character interactions through an interactive network graph. The application is deployed on AWS using the AWS Cloud Development Kit (CDK), which automates the setup of AWS Lambda for backend processing and API Gateway for handling requests efficiently.

sql-cursor-ai-agent
This project is a tool that helps you create SQL queries using AI technology. It has a web interface that works like Cursor, making it easy to use. The system uses two different AI agents that work together: one agent talks with you to understand what you need, and another agent creates the actual SQL code.

langchain-agent-streamlit
This project represents a cutting-edge integration of LangChain and Large Language Models (LLMs) to enhance the processing and comprehension of web search results, aiming to refine and reconstruct truncated information for improved clarity and user engagement. By leveraging advanced NLP techniques and custom tool development, we have successfully created an intelligent agent capable of consulting previous messages, conducting web searches, and presenting human-readable summaries without the common ellipsis truncation.

gpt-context-injection
This project focuses on leveraging the powerful combination of the GPT API, Elasticsearch, and SpaCy to implement a specialized chatbot capable of context injection. The chatbot's primary objective is to ingest and analyze data from a specific WordPress blog, providing relevant and contextual responses to user queries.

openclaw-agent
This project is an autonomous AI agent client that uses the OpenClaw SDK to connect to a local OpenClaw gateway over WebSocket for agent interactions, including messaging channels such as WhatsApp and Telegram. It includes a Docker-based gateway and integration with Google Vertex (Gemini) for scalable, cloud-backed agent workflows.

higgs-boson-machine-learning
This project develops advanced machine learning models to detect Higgs boson signals in particle physics data, utilizing scikit-learn for feature engineering and statistical analysis. It includes comprehensive data visualization with Matplotlib and Seaborn to explore and validate model performance on high-energy physics datasets.

html2vec
The project involved developing an algorithm to convert HTML documents into vectorized objects suitable for use with neural networks. The algorithm used a combination of techniques, including HTML parsing, natural language processing, and dimensionality reduction. The resulting vectors could then be used as inputs for machine learning models to perform tasks such as document classification or information retrieval. The implementation was done in Python, using libraries such as BeautifulSoup and Scikit-learn.

search-keras-gensim-elasticsearch
This project builds a semantic search engine that combines Word Embeddings (GloVe) with Elasticsearch, enabling efficient text similarity search and content recommendation. It leverages Keras and Gensim for embedding generation and integrates with Elasticsearch for scalable indexing and retrieval of document collections.

deep-age-classifier
This project develops a CNN-based age detection system using Keras, implementing transfer learning for accurate facial age estimation from images. It includes comprehensive data preprocessing pipelines and is designed for robust performance on real-world face datasets.

keras-nltk-topic-modeling
Implementation of a Neural Network to classify text with Python and Keras. Python Keras NLP Neural Networks Text Classification Topic Modeling Matplotlib SpaCy POS tagging Lemmatization.

keras-document-classifier
The project involved building a document classifier using a neural network implemented with Keras. Data was scraped using the Newspaper3k library and the Google Search API to obtain a corpus of articles related to the topic. The articles were preprocessed using spaCy for POS tagging and lemmatization. The model was trained on this data and evaluated using various performance metrics. AsyncIO and aiohttp were used for asynchronous data retrieval and web scraping, respectively.

python-recommender-systems
This project creates a fully serverless personalized recommendation engine using AWS Lambda, NumPy, and Algolia, delivering low-latency suggestions through collaborative filtering and novelty and diversity algorithms. It is designed for scalable, cost-effective recommendation APIs without dedicated servers.

graph-link-prediction
The project utilizes Keras and Deep Learning to perform link prediction in a heterogenous information network, enabling accurate predictions between entities of different types.

python-deep-learning-algorithms
This project implements advanced deep learning algorithms in Python, focusing on efficient numerical computing with NumPy and scientific computing with SciPy. It demonstrates core concepts and optimizations used in building and training neural networks and related models.

supply-chain-optimization
This project engineers a supply chain optimization system using Python and NumPy, implementing efficient algorithms for logistics and resource allocation. It addresses routing, inventory, and allocation problems with numerical and optimization techniques suitable for real-world constraints.

python-monte-carlo-simulator
This project builds a sophisticated Monte Carlo simulation framework using Python and SciPy, enabling complex probabilistic modeling and statistical analysis. It supports scenario generation, sampling, and result aggregation for applications in finance, science, and engineering.

statistical-distributions
This project aims to utilize the powerful scipy library to perform statistical analysis on various distributions and identify the ones that best fit a given dataset. The project will involve analyzing and visualizing the results to gain insights into the underlying distribution of the data.

genetic-paper
This project implements genetic algorithms with a focus on algorithmic complexity analysis, enabling efficient optimization and problem-solving strategies. It uses mutation, crossover, and selection to evolve solutions and includes analysis of performance and scalability.

opengl-samples
This project demonstrates advanced OpenGL rendering techniques by implementing a real-time 3D scene with multiple camera perspectives. It features three distinct geometric objects (a cube, a pyramid, and a prism) rendered with Phong-Blinn lighting and dynamic shading. The application showcases both a primary and a secondary camera, with the secondary camera's view displayed as a floating minimap overlay within the main window. The project includes custom framebuffer management, real-time object animation, and interactive window resizing, all built using modern OpenGL (Core Profile 3.3), GLFW, GLEW, and GLM for matrix and vector operations.

image-classification-transformer
This project involves developing a deep learning model for classifying different types of apparel from images, such as T-shirts, trousers, pullovers, dresses, and more. Using a pre-trained Vision Transformer (ViT) as the base model, the project enhances it with additional layers to improve classification accuracy. The model is trained with techniques like data augmentation, batch normalization, and dropout to reduce overfitting and enhance performance. The training process includes handling class imbalances by sampling more instances of underrepresented classes, and the optimizer is fine-tuned to focus on these new layers.

keras-image-detection-classification
The project involved building a model for text classification by first conducting topic modeling using the Natural Language Toolkit (nltk) in Python. After identifying the most relevant topics, a neural network was implemented using the Keras library to classify text into those topics. The text was preprocessed using SpaCy for part-of-speech tagging and lemmatization. The accuracy of the model was visualized using Matplotlib. The project also included a comparative analysis of the performance of the neural network model against other classification models.

python-video-processing
The program uses MoviePy to manipulate video files, OpenCV2 to perform image processing, and NumPy to manipulate arrays of video data. The project involves complex algorithms for transforming video frames, including blending, resizing, and overlaying videos. The movie generator is highly customizable, allowing users to adjust settings such as the video duration, frame rate, and output format.

media-tools
This project builds a video processing pipeline using FFMPEG, implementing efficient media conversion and manipulation through shell scripting. It automates encoding, decoding, format conversion, and batch processing of video and audio files from the command line.

pyspark-docker
This GitHub project demonstrates the innovative integration of PySpark within Docker containers, illustrating a scalable and efficient approach to processing large datasets in distributed computing environments. By leveraging Docker's virtualization capabilities alongside PySpark's powerful data processing engine, the project offers a blueprint for building and deploying scalable data analytics applications. It showcases how to encapsulate PySpark applications in Docker, ensuring consistency, portability, and ease of deployment across different environments.

apache-hive-docker
The project involved implementing a Hive server using Docker Compose, which reads and writes data to HDFS. The project also included using the Hive CLI, web interface, and Python PyHive library to interact with the Hive server. The goal was to demonstrate the versatility and ease of use of Hive and Docker Compose in setting up and managing a data processing pipeline with HDFS.

hadoop-hdfs-map-reduce-docker
The project involved setting up a Hadoop Distributed File System (HDFS) using Docker and Docker Compose, followed by submitting a MapReduce job to the cluster. The web interface of the History Server was used to monitor the progress of the job.

hadoop-hdfs-kafka-docker
This project leverages Docker Compose to run an Hadoop Distributed File System (HDFS) cluster, along with YARN and ZooKeeper, as well as Kafka. Python is used as both the producer and consumer to send and consume data into a Kafka topic, enabling distributed data processing and storage using a familiar language and ecosystem.

hadoop-hdfs-hbase-docker
The project is a Docker-based solution for storing unstructured data in HBase with HDFS as the underlying storage system. It includes a Python client for easy data storage and retrieval, making it an ideal solution for managing large volumes of data.

sparkql
This project develops efficient SparkSQL queries for big data processing, enabling complex data transformations and analytics. It demonstrates how to structure and optimize SQL-style operations on distributed datasets using Apache Spark.

pandas-geo-analytics
The project involved analyzing geolocation data using Pandas in Python. The data was obtained from GPS devices and contained latitude, longitude, and timestamps. The objective was to identify patterns and trends in the data to gain insights into the behavior of individuals and groups. Data cleaning techniques were applied to remove outliers and missing values. The cleaned data was then grouped and aggregated to calculate metrics such as distance traveled, speed, and duration. Visualization techniques such as heat maps and scatter plots were used to represent the data visually.

cross-datasource-entity-matching
The project leverages Deep Learning algorithms to perform Record Linkage, or entity matching, by comparing and matching data from separate datasources. By utilizing Deep Learning, the project can accurately identify and link similar entities, streamlining data integration and reducing errors.

supabase-python
This project provides a lightweight Python interface for working with Supabase in backend workflows, enabling developers to programmatically interact with Supabase services such as the PostgreSQL database, authentication, and storage from Python applications. It is designed for engineers who want to integrate Supabase into Python-based systems, scripts, or backend services without relying on JavaScript tooling, offering a clean and minimal API for performing common operations like querying tables, inserting and updating records, and managing data pipelines.

aws-localstack-stream-processing
This project implements a scalable, event-driven architecture for secure transaction signing using AWS LocalStack for local emulation. It ingests high-throughput unstructured data into Kinesis, persists raw inputs to S3 for replay, and routes records through an intermediate batching stream that triggers a Lambda function. The Lambda retrieves RSA private key ARNs from Aurora Serverless, signs the batched data, and stores signed payloads in a separate S3 bucket. Built with CDK and Docker Compose, the system ensures reliable, exactly-once processing with optimized Lambda performance and modular RSA key management via AWS Secrets Manager.

aws-sagemaker-cdk
This project automates the deployment and management of multiple machine learning models using AWS services like SageMaker, Lambda, API Gateway, and EventBridge, ensuring seamless integration and scalable real-time inference.

gcp-kubernetes
This project involved setting up a Kubernetes cluster on Google Cloud Platform using Google Cloud Deployment Manager, automating the creation and management of GCP resources. I developed YAML and Jinja templates to efficiently deploy a multi-node Kubernetes cluster, enhancing scalability and availability.

aws-django-ansible
The project utilizes Ansible in a Docker container to implement a Django application. It provides flexibility by connecting to AWS EC2 instances, allowing seamless deployment and management of the application in both local and cloud environments.

grpc-python
This project implements high-performance gRPC services in Python, enabling efficient microservices communication and streaming. It provides a foundation for building scalable, type-safe APIs and real-time data exchange between services using protocol buffers.

terraform-aws-django
The project aims to automate the deployment of a Django application using Terraform. It provisions an EC2 instance in a public subnet, installs necessary dependencies, and runs the application using Gunicorn.

aws-django-kubernetes
The project utilized Django as the primary technology stack for building a web application that was deployed on AWS Kubernetes. The application made use of Kubernetes for container orchestration and management, while Django provided a framework for building the RESTful APIs that the application relied on. The system also integrated with various AWS services such as S3 for file storage and RDS for database management.

aws-networking-elastic-beanstalk-automation
The project utilized AWS CDK to create multiple Cloud Formation stacks for deploying various AWS services. These services included an AWS network, an RDS instance, an Elasticache cluster, an OpenSearch service, and an Elastic Beanstalk instance. AWS CDK allowed for the creation of infrastructure as code, providing a more streamlined and consistent approach to deployment.

supervisor-python
The project is a Python script managed by Supervisord, creating a daemonized service that runs continuously on Linux and automatically restarts if crashed, providing robust and reliable system operation.

python-splunk-cli
This project develops Python integration with Splunk for log analysis and monitoring, enabling efficient log processing and visualization. It offers a CLI and programmatic access to query logs, run searches, and automate operational insights from Splunk data.

filesystem-tools
This project engineers file system management tools with AWS S3 integration, enabling efficient cloud storage operations and automation. It supports uploads, downloads, sync, and scripting for bulk and recurring storage tasks on Linux and cloud environments.

development-tools
This project creates comprehensive development tools for Python, Android, TypeScript, Django, Git, and GPT integration. It bundles scripts and utilities to streamline local development, version control, and AI-assisted workflows across multiple stacks.

python-jira-cli
This project develops Python integration with JIRA, enabling automated issue tracking and project management. It provides a CLI and API helpers to create, update, and query issues and projects programmatically from scripts and toolchains.

web-to-pdf
This project engineers web scraping tools using Python and Beautiful Soup, enabling efficient content extraction and PDF conversion. It fetches web pages, parses structure and text, and generates PDFs for offline reading or archival.

python-web-crawler
The project involved using Python and the asyncio library to create a web crawler that could efficiently scrape and process data from multiple websites simultaneously. The crawler was designed to handle large volumes of data by using asyncio's event loop to manage concurrent requests and minimize blocking I/O operations. The project also made use of other Python libraries such as requests, BeautifulSoup, and pandas to extract, process, and analyze the scraped data.

bitcoin-wallet-generator
This project provides code for generating Bitcoin wallets that can store BTC without relying on third-party services like Blue Wallet or Electrum. It demonstrates key generation, address derivation, and secure storage of keys for self-custody of Bitcoin.

ethereum-wallet-generator
This project provides code for self-custody of Ethereum without relying on third-party wallets like MetaMask. It derives BIP39/BIP44 accounts, converts seed phrases into private and public keys, checks ETH and ERC-20 balances, proves address ownership, signs messages, and builds and signs EIP-1559 transactions locally to send ETH or tokens.

real-estate-solidity-contract
This project develops secure and auditable real estate smart contracts in Solidity, implementing Merkle trees for efficient property verification on-chain. It supports proof of ownership, transfers, and compliance checks in a decentralized real estate workflow.

solidity-upgradeable-contract
This project is a Solidity-based upgradeable smart contract system leveraging OpenZeppelin's upgradeable libraries to provide secure and flexible access control, signature verification, and contract management. It includes a Manager contract that handles role-based access control, pausability, upgradeability with state migration, and integration with an external Verifier contract for validating user signatures. Built with Foundry for testing and deployment, the system ensures security through strict role enforcement, robust error handling, and seamless upgrade mechanisms.

rust-alloy
This project is a Dockerized Rust API that leverages Tokio, Warp, Alloy, Foundry, and Grafana to interact with Ethereum nodes, providing balance queries and real-time monitoring. It integrates Anvil for local Ethereum development, OpenTelemetry for tracing, and Prometheus + Grafana for monitoring, making it a robust solution for blockchain-based applications. The API is built with Warp for high-performance async HTTP handling and supports structured logging, CORS, and OpenTelemetry tracing. With a simple Docker Compose setup, it allows seamless deployment and local development, ensuring a production-ready Ethereum API environment.

zk-trust
This project, titled zk-trust, leverages Zero-Knowledge Proofs to enhance security in the DeFi ecosystem by verifying the attributes of ERC20 tokens before they are listed on platforms. By implementing a robust validation mechanism off-chain and confirming the authenticity on-chain via a Solidity smart contract, this system helps prevent fraud similar to the recent Ionic Money Hack, ensuring only legitimate tokens are used within the platform.

zk-proof
This project demonstrates a zero-knowledge proof system using RiscZero's zkVM. It compiles a guest program located in the ./methods/guest directory into an ELF binary, which is then executed by a host Rust application that also runs a Warp server. The server exposes endpoints to remotely trigger zkVM executions, allowing users to submit inputs, obtain the computed result along with a cryptographic proof of execution, and ultimately validate that proof on-chain. The entire process is containerized using Docker, ensuring a reproducible and isolated environment for development and deployment.

anvil-of-fury
This project involved the development of an Ethereum-based application using the Web3.js library, which provided an engaging platform to interact with the blockchain. My role encompassed setting up a local development environment using Anvil, crafting scripts for sending transactions, and managing wallet balances. I successfully implemented functionality to handle cryptocurrency transactions dynamically by connecting to and interacting with a simulated Ethereum network. This experience enhanced my understanding of blockchain technology, Ethereum smart contracts, and the intricacies of transaction fee mechanisms.

ethereum-solidity-contract
The project involved developing a smart contract on the Ethereum network using Solidity programming language. The contract was designed to facilitate a decentralized voting system that could be implemented across various organizations. The contract was created to ensure transparency and security in the voting process while also reducing the potential for fraud. Additionally, the project involved testing the smart contract using the Remix IDE and deploying it to the Ethereum network using tools like Ganache and Truffle. The smart contract was deployed on a private network and was also tested using the Ropsten test network.

django-multi-blockchain
The project involves building a cross-chain environment where users can log in to a Django SSO (Single Sign-On) server and access other Django servers connected to the Solana, Ethereum, and Polygon networks. The SSO server is responsible for authentication and authorization, while the other servers are responsible for interacting with their respective networks.

solana-token-rust
The project involved creating a Solana NFT using CandyMachine, a tool that allows creators to mint NFTs on the Solana blockchain, and Rust Programs. Rust was used to write the smart contract that governs the creation, distribution, and sale of the NFTs. The NFTs were stored on the Solana blockchain, making them easily transferable and secure.

rust-ecopark
This project builds a high-performance database application in Rust, implementing efficient MySQL queries and Docker containerization. It offers a fast, reliable backend for data access and is designed for deployment in containerized and cloud environments.

django-admin-react
This project is a drop-in React single-page admin for any Django 5+ project, modernising Django's classic hypertext admin without requiring any frontend code from the developer. The package is metadata-driven: it learns your models, fields, and permissions at runtime from a registry endpoint, and renders virtualised tables, mobile-friendly layouts, inline editing, filters, search, bulk actions, autocomplete pickers, and inlines directly from your existing ModelAdmin classes. Permissions, querysets, fieldsets, and read-only rules are honoured verbatim, so a new ModelAdmin only requires a page refresh — no rebuild or codegen.

django-admin-rest-api
This project exposes every ModelAdmin already registered on the Django admin site through a JSON REST API, without introducing a parallel permission system, a parallel form layer, or any feature the Django admin itself does not have. Authentication, authorization, field validation, actions, search, filters, and audit logging are all delegated to the existing Django setup: requests run through the same ModelForm, the same has_view/add/change/delete_permission checks, and Django's own LogEntry history. It is the stable wire surface that powers django-admin-react and django-admin-mcp-api.

django-admin-mcp-api
This project is an MCP (Model Context Protocol) adapter for the Django admin that lets AI agents read rows, retrieve, create, update, and delete records, run admin actions, and use autocomplete through the standard MCP protocol. It is a thin wire-protocol layer sitting on top of django-admin-rest-api — the same authentication, the same permissions, no extra validation, and no new business logic — so it safely exposes the Django admin's existing capabilities to LLMs.

django-admin-graph
This project is a Django package that turns the admin site into a typed, versioned graph of apps, models, relations, ModelAdmins, actions and permissions, filtered by each user's own admin permissions. It exports JSON, Mermaid ER diagrams, GraphViz and networkx, and is the schema layer that AI agents and django-admin-skills read.

django-admin-skills
This project generates Agent Skills (SKILL.md plus per-model references) for Claude Code, Codex and Gemini CLI from a Django admin, using django-admin-graph as its only source of truth. Generated for a given user, a skill teaches an agent only what that account may do through django-admin-rest-api or django-admin-mcp-api; files are schema-only and neutralised against prompt injection, and a check mode fails CI when the skill goes stale.

geometry.martincastroalvarez.com
This project is a computational geometry application implementing art gallery algorithms, convex decomposition, and guard placement from first principles. It includes a React web app for visualization, a Python API for computations, and AWS CDK for deployment and hosting.

python-fastapi
This project engineers a high-performance REST API using FastAPI, implementing async operations and automatic OpenAPI documentation. It is designed for low-latency, scalable backends with built-in validation, dependency injection, and interactive API docs.

geo-django
The project is a geospatial application that leverages GeoDjango and PostGIS to create and manage multiple points, lines, and polygons. It calculates distances between these objects and performs various operations using them to support geospatial analysis and visualization.

hexagonal-spring-boot
The project utilizes Hexagonal Architecture in Java Spring Boot for e-commerce management with a React and Tailwind frontend. It features domain models, service interfaces, and custom exceptions to streamline operations, supported by comprehensive unit tests. Key functionalities, including user and product management, are demonstrated in interactive demos. The architecture promotes modularity and ease of maintenance, ensuring adaptability and scalability through well-defined web and database API adapters.

node-typescript-pdf-renderer
The project involved utilizing NodeJS and TypeScript to dynamically render PDFs based on user input. NodeJS provided a reliable and efficient backend framework for handling data processing and file generation, while TypeScript was used to ensure type safety and code consistency. The project also made use of various PDF generation libraries such as pdfkit and Puppeteer to facilitate PDF rendering.

ai-syntax-compiler
This project develops a custom programming language compiler for data scientists, implementing lexical analysis and parsing using Bison and Lex. It defines a small DSL and toolchain for expressing data and analytics operations with a dedicated syntax and runtime.

automata-python
This project implements various automata algorithms in Python, enabling efficient pattern matching and language processing. It covers finite automata, regular expressions, and related constructs used in compilers, parsers, and text processing.

java-spring-boot
The project utilized Java Springboot as the main technology stack for building a web application. Springboot provided a framework for creating RESTful APIs, which were used to handle user requests and data retrieval from a MySQL database. The application also implemented security features such as user authentication and authorization using Spring Security. Overall, Springboot proved to be a reliable and efficient tool for building a scalable web application.

data-structures-java
This project implements efficient data structures in Java, focusing on performance optimization and algorithm complexity. It provides well-tested implementations of trees, heaps, graphs, and other structures with clear APIs and complexity guarantees.

django-data-analytics
This project builds a comprehensive data analytics platform using Django, implementing PnL, LTV, and retention analysis. It offers dashboards, reports, and APIs for business and product metrics with a Django-backed storage and computation layer.

go-lang-app
This project develops high-performance applications using Go, implementing concurrent processing and efficient resource utilization. It leverages goroutines and channels for concurrency and is suited for services requiring low latency and high throughput.

django-cms
This project is a Content Management System (CMS) built using the Django web framework. The CMS will enable users to create, edit, and publish digital content, such as articles, blog posts, and multimedia files, using an intuitive web-based interface. The CMS will also include features such as user authentication, content versioning, and search functionality.

flask-mongodb-celery-messaging-api
This project involved the implementation of a chat server using Redis, Celery, MongoDB, and Flask. Redis was used for message queueing and socket management, while Celery was used for asynchronous task processing. MongoDB was used to store user information and chat history, and Flask was used to provide the web interface. The project also involved implementing a RESTful API for mobile client communication.

python-s3-media-server
This project develops a file server using Flask and PIL, implementing efficient image processing and S3 storage integration. It serves and transforms images on demand and persists assets to AWS S3 for scalable media hosting.

python-chat-server-sockets
This project engineers a real-time chat server using Python sockets, enabling efficient network communication and message handling. It supports multiple concurrent clients and demonstrates low-level TCP socket programming and protocol design.

python-google-spreadsheets
This project develops Python integration with Google Spreadsheets, enabling automated data processing and analysis. It uses the Google Sheets API to read, write, and transform spreadsheet data from scripts and pipelines.

software-patterns
This project implements various software design patterns in Python, demonstrating best practices for maintainable and scalable code. It includes examples of creational, structural, and behavioral patterns with clear use cases and trade-offs.

react-pnpm-workspaces
This project is a monorepo template for sharing UI components between React web and React Native mobile apps using pnpm workspaces. It demonstrates platform-specific implementations with Vite, Expo, and TypeScript in a scalable architecture for cross-platform development.

microfrontends
The project is centered on implementing a distributed frontend architecture for medium and large companies. It aims to enhance scalability and maintainability in web development by modularizing the frontend, thus facilitating smoother collaboration and more agile processes in complex, large-scale applications.

nextjs-app
This project builds a modern web application using Next.js, implementing server-side rendering and optimized performance. It leverages file-based routing, API routes, and static or dynamic rendering for fast, SEO-friendly web experiences.

vuejs-app
This project develops a responsive web application using Vue.js and TypeScript, implementing component-based architecture. It uses the Composition API and type-safe patterns for maintainable, reactive user interfaces and single-page applications.

svelte-app
This project engineers a high-performance web application using Svelte, implementing reactive programming and efficient DOM updates. It compiles to minimal JavaScript and uses reactive declarations for fast, lean front-end experiences without a virtual DOM.

react-typescript-app
This project builds a type-safe React application using TypeScript, implementing modern frontend development practices. It combines React components with strict typing, hooks, and tooling for reliable and maintainable user interfaces.

react-firebase-oauth
The project is a React application that uses Firebase and Google OAuth 2.0 authentication for secure user access to protected resources. It includes custom login and registration forms, and utilizes modern web technologies such as React, JavaScript, and CSS. Integration with third-party libraries and services enhances the overall reliability and robustness of the application.

flexbox-project
The project is a web development endeavor aimed at implementing flexbox, a powerful layout system used in modern CSS, with a focus on creating flexible and responsive designs. Through this project, developers will gain an understanding of the different properties and techniques that can be utilized to achieve custom layouts for their web pages. By leveraging flexbox, users will be able to create dynamic and adaptive interfaces that adjust to the size and orientation of various devices.

typescript-map-reduce
This project engineers efficient data processing using TypeScript, implementing map-reduce patterns for large datasets. It demonstrates how to partition work, aggregate results, and handle streaming or batch data in a type-safe Node or browser environment.

typescript-mongodb-nestjs-mvc
This project builds a full-stack MVC application using TypeScript, MongoDB, and NestJS, implementing clean architecture principles. It provides a structured backend with dependency injection, modules, and MongoDB integration for scalable API and data layers.

typescript-classes
This project implements object-oriented programming patterns in TypeScript, demonstrating advanced class design and inheritance. It covers encapsulation, abstraction, and type-safe OOP constructs for structuring front-end or Node.js applications.

dam
Full-stack digital asset management with a React 19 and TypeScript frontend (Vite, Tailwind CSS, React Router, Formik, Yup) and a Firebase backend: Auth, Firestore, Cloud Storage, and Node.js Cloud Functions. Local development runs the Firebase Emulator Suite in Docker for isolated Auth, Firestore, Storage, and Functions.

cypress-tests
This project showcases the integration of Cypress tests within a web development environment, emphasizing the crucial role of automated testing in building robust, error-free applications. By leveraging Cypress, an advanced end-to-end testing framework, the project aims to demonstrate best practices in test automation for both small and large-scale web projects.

flask-application
This project engineers a Flask REST API with 100% unit test coverage, implementing robust testing practices and continuous integration. It serves as a reference for building well-tested Python APIs and integrating them into CI/CD pipelines.

javascript-selenium-web-driver
This project builds an automated testing framework using Selenium WebDriver, enabling comprehensive browser-based testing. It automates user flows, assertions, and cross-browser checks for reliable end-to-end and regression testing of web applications.

python-android-manager
This project develops a web API for remote Android device emulator management, enabling efficient mobile testing and automation. It allows teams to control emulators, install builds, and run tests from CI or scripts for scalable mobile QA workflows.

unlam-android-app
This project engineers a native Android calendar application, implementing efficient data management and user interface. It provides event creation, editing, and scheduling with a native UI and local or synced storage for personal or educational use.

quantum-algorithms-java
The project involved using Java to implement quantum algorithms for various applications. Java was chosen for its versatility, and the quantum algorithms were implemented using the Qiskit library. The project also utilized various quantum simulators to test the algorithms, including the IBM Quantum Experience platform. Overall, the use of Java proved to be effective in implementing complex quantum algorithms, and the project provided valuable insights into the potential applications of quantum computing.

assembly-logisim-circuits
This project develops digital logic circuits using Logisim, implementing assembly language programming and circuit simulation. It demonstrates how to design and simulate low-level hardware and instruction sets for educational or prototyping purposes.