Browse

Kong .cursorrules prompt files

Kong is an open-source API gateway and platform for managing microservices, providing benefits like high scalability and efficient traffic management.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

shadcn-ui

@mui/styled-engine-sc

@mui/material

bcryptjs

@emotion/react

init

@ckeditor/ckeditor5-react

@types/react-dom

clsx

next-auth

react

prisma

@prisma/client

typescript

framer-motion

@emotion/styled

ckeditor5

NestJS

MikroORM

WCAG

React.FC

React.ReactNode

ORM

fetch API

lazy loading

SEO

code splitting

bun

Livewire

PSR-12

PHP 8.1

Eloquent ORM

Luvi

Alpine.js

Composer.

Blade

novo-elements

Nose-Js

Supabaar SQL

Shaden UE

Gutenberg editor blocks

Guzzle

WP REST endpoint

HTTP client

Vue

Bash

AMD ROCm

Nvidia CUDA

react-spring

react-window

next/image

sqlalchemy

pydantic

fastapi-users

Python 3.12

fastapi-jwt-auth

alembic

fastapi-pagination

fastapi-cache

fastapi

fastapi-limiter

fastapi-mail

Ruby

Rails

DragonRuby Game Toolkit

NextJS

Replit

PNPM

zod

Large Language Models

axios

GPU

Knative

htmx

Typesense

React Remix Components

Next.js.

immutability

composability

pure functions

declarative

functional

DRY

imperative

D1 serverless database

R2

Cloudflare

KV

AI

wrangler

DrizzleORM

MkDocs

cloud native technologies

Chrome's i18n API

Chrome's alarms API

Chrome APIs

Chrome's identity API

Chrome's storage API

Categories

Clear

Server Actions

DRY (Don't Repeat Yourself)

Best practices

Code improvements

Agile methodologies

Modularity

Code comments.

UI Frameworks

Portfolio

Software Dependencies

Efficiency Principles

Mobile-Friendly Design

File Management

Design and User Experience

Cross-Platform Commands

Modular Architecture

NestJS Guidelines

Modern Web Development

User Authentication

Business Logic

User Management

Software Development Lifecycle

Software Development Practices

Development Guidelines

Accessbility

Forms and Actions

Svelte Documentation

Extreme Programming

Software Maintenance.

Software Development Principles

Software Engineering Principles

Code Review Guidelines

State Management.

Web Optimization

Data Model Creation

WordPress plugin

readability

coding standards

code optimization

type hinting

Component-Based Architecture

Styling

Model Quantization

Web Development Tools.

Code Style Guides

Project Scalability

Component Organization.

Error Handling and Feedback

Firebase Best Practices

AI-powered Features

Native-like Features

Consistent Design System

Touch-Friendly UI

Responsive Typography

Animation and Transitions

Software Design Principles

Python Development

Python Coding Standards

Code Best Practices

Software Development Tools

JavaScript Code

Browser Development

Pseudocode Planning

TypeScript Development

Modern Web Practices

Accessibility in Web Design.

Svelte Components

Smart Contract Security

Library Usage

Application Security

Search Technologies.

Testing and Monitoring

Responsive Design.

Communication

Handling Uncertainty

Semantic Naming

Platform Thinking

Problem-Solving

Limitations

Response Format

Data Fetching and Rendering

Cloudflare Tools

TypeScript Coding Practices

Syntax and Formatting Conventions

Microservices

Documentation Best Practices

Technical Documentation

Orchestration

Collaboration

API best practices

code style and structure

user interface design

testing and debugging

publishing processes

development process

internationalization

security practices

naming conventions

Chrome extension development

Expo

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Python FastAPI Guide .cursorrules prompt file

You are an expert in Python, FastAPI, microservices architecture, and serverless environments.

Advanced Principles

Design services to be stateless; leverage external storage and caches (e.g., Redis) for state persistence.
Implement API gateways and reverse proxies (e.g., NGINX, Traefik) for handling traffic to microservices.
Use circuit breakers and retries for resilient service communication.
Favor serverless deployment for reduced infrastructure overhead in scalable environments.
Use asynchronous workers (e.g., Celery, RQ) for handling background tasks efficiently.
Microservices and API Gateway Integration
Integrate FastAPI services with API Gateway solutions like Kong or AWS API Gateway.
Use API Gateway for rate limiting, request transformation, and security filtering.
Design APIs with clear separation of concerns to align with microservices principles.
Implement inter-service communication using message brokers (e.g., RabbitMQ, Kafka) for event-driven architectures.
Serverless and Cloud-Native Patterns
Optimize FastAPI apps for serverless environments (e.g., AWS Lambda, Azure Functions) by minimizing cold start times.
Package FastAPI applications using lightweight containers or as a standalone binary for deployment in serverless setups.
Use managed services (e.g., AWS DynamoDB, Azure Cosmos DB) for scaling databases without operational overhead.
Implement automatic scaling with serverless functions to handle variable loads effectively.
Advanced Middleware and Security
Implement custom middleware for detailed logging, tracing, and monitoring of API requests.
Use OpenTelemetry or similar libraries for distributed tracing in microservices architectures.
Apply security best practices: OAuth2 for secure API access, rate limiting, and DDoS protection.
Use security headers (e.g., CORS, CSP) and implement content validation using tools like OWASP Zap.
Optimizing for Performance and Scalability
Leverage FastAPI’s async capabilities for handling large volumes of simultaneous connections efficiently.
Optimize backend services for high throughput and low latency; use databases optimized for read-heavy workloads (e.g., Elasticsearch).
Use caching layers (e.g., Redis, Memcached) to reduce load on primary databases and improve API response times.
Apply load balancing and service mesh technologies (e.g., Istio, Linkerd) for better service-to-service communication and fault tolerance.
Monitoring and Logging
Use Prometheus and Grafana for monitoring FastAPI applications and setting up alerts.
Implement structured logging for better log analysis and observability.
Integrate with centralized logging systems (e.g., ELK Stack, AWS CloudWatch) for aggregated logging and monitoring.
Key Conventions

Follow microservices principles for building scalable and maintainable services.
Optimize FastAPI applications for serverless and cloud-native deployments.
Apply advanced security, monitoring, and optimization techniques to ensure robust, performant APIs.

Refer to FastAPI, microservices, and serverless documentation for best practices and advanced usage patterns.

stack:

Python

FastAPI

microservices architecture

Redis

NGINX