Browse

software components .cursorrules strategies

Filters

Tech

Clear

dataclasses

Hono

Kong

AWS Lambda

AWS CloudWatch

RQ

Azure Functions

OAuth2

AWS API Gateway

microservices architecture

eslint

Deno

ServeMux

expo-localization

HTTPS

Detox

React Native Testing Library

fetch

RSC

Server Actions

Sentry

Server Components

React Query

Expo Router

CSS frameworks

Istio

js-yaml

mime-types

uuid

node-gyp

Ruby

poetry

next/image

Formik

Framer Motion

Linux

Netlify

Less

MDX

Sass

WordPress

Paraglide.js

PHPUnit

Alpine.js

Livewire

Dusk

JSON Web Tokens

Mongoose ODM

React.js

SEO

fetch API

React.ReactNode

React.FC

WCAG

Supabase Auth

react-dom

postcss

framer-motion

prisma

@types/node

Next.Js

@types/react

bcryptjs

autoprefixer

Material UI

yarn

WebAssembly

Composer

Biome

Cairo

Tailwind CSS.

Kotlin

Rell

React Server Components (RSC)

Angular

Next.js 14 App Router

Next.js SSR.

Axios

Cypress

Kubernetes

NoSQL

AWS

pytest-django

WhiteNoise

unittest

Django REST Framework

pip

python-dotenv

NumPy

joblib

Flask

tqdm

PyTorch

dask

virtual environments

Pytest-Recording

CliRunner

Pytest

VCRPy

Loguru

Categories

Clear

Image and Audio Matching

Database Operations

User Interface design

HTML coding

Open source development

React development

Audio recording

Screen recording

JavaScript coding

Mechanical keyboard

Go Best Practices

Standard Library Usage

Rate Limiting

Input Validation

HTTP Methods

Agent Framework

Folder Structure

React Hooks

Code Standards

User Dashboard

Application Development

Nuxt.js

Modern JavaScript

CSS Best Practices

Subscription Management

React Programming Patterns

Testing and Documentation

Video Application

Code Style Guidelines

Code Styling and Structure

Web Performance Optimization

Backend

Module Bundling

Security Audit

Frontend Optimization

Database Optimization

Testing Strategy

Monorepo

Cloud Architecture

Frontend Design

Observability

Serverless Deployment

API Gateway

Monitoring and Logging

Code Guidelines

Flutter Development

Frontend

Backend.

Logging and Metrics

Progressive Enhancement

Website Design

Minimalist JavaScript

YAML Configuration

Responsive design

ARIA

Code documentation

JavaScript conventions

CSS styling

AI development

Automation tools

Agent frameworks

Communication tools

Database Integration

Middleware

3D Game Development

Simulation Games

Entity Component System (ECS)

Java Source Code Management

File Naming Conventions

Code Structure and Organization

Java Project Organization

Java Documentation Practices

Modern Java Features

Best Practices for Java Programming

Ethical and Professional Practices

Java Naming Conventions

Java Core Principles

Code review

Project adaptability

Operational management

Next.js 14

AI agents

Test driven development

Type-safe APIs

Code optimization

Database management

Mobile development

Monorepo management

Schema validation

Cross-platform applications

Programming Languages

Software Documentation

Scripting

Cross-Platform Development

content management

metadata handling

block-based development

semantic HTML

spreadsheet integration

GitHub integration

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Graphical Apps Development .cursorrules prompt file

# Project Synopsis
Pyllments is a Python library for building graphical and API-based LLM applications through chaining together Elements in a potentially cyclic graph.

Elements and Payloads are a type of Components. A Component is composed of a Model and Views. The Model handles the underlying data and logic, while the Views are the UI components that are used to display display the interactive UI used to interact with the Model.
An Element is a type of Component that is responsible for a specific function. For instance, an Element can handle the LLM selection and generation by making calls to LLM providers. Another Element may handle the chat interface, whose Model would store the chat message history, and the Views would be the text boxes and buttons used to interact with the chat interface. Elements are meant to connect to other Elements through Ports. All that is necessary to link Elements together is to link the output port of one Element to the input port of Another. Each output port may have unlimited input ports it connects to, and each input port may have unlimited output ports it connects to. The ports follow an observer pattern where the output port is the subject and the input port is the observer. The subject notifies the observers when a certain event that we set within the Element is triggered.
In order to connect an input and and output port, they need to be setup in a manner that sends and receives the same type of Payload. A Payload is also a Component with a Model as well as views responsible for the display logic. Elements may receive payloads and use methods of the Payload to generate the views for the UI. The sending Element is responsible for packing data into the Payload.

I am currently working on making this a fully-fledged framework.

# Project Organization
Here is an example of the file structure of an individual element:
chat_interface:
  - __init__.py
  - chat_interface_element.py
  - chat_interface_model.py
  - css:
    - buttons.css
    - column.css
    - input.css

# Primary Libraries Used
- Panel is used to create the visualization layer and run the GUI. Views tend to consist of Panel objects which can be styled with Python and CSS.
- Param is used to create parameterized classes which help create parameters that handle type validation, default values, constraints, and most importantly, reactivity(setting event handlers to catch changes).
- Langchain is responsible for the specific functions pertaining to incorporating LLM workflows.

# Development Priorities
Pyllments code is prioritized on being developer-friendly, where extensibility and modularity are first-class citizens. Elements should be customizeable with clean and intuitive interfaces. It should also be easy to create new elements depending on the needs of the developer.

# Documentation
Docstrings should use a NumPy/SciPy style.

stack: