simonwllm

A Python function that can produce multiple values over time, allowing other code to run while waiting for each value. It uses 'async' and 'yield' keywords to enable non-blocking streaming.

A command-line interface that acts as a simplified front-end to a more complex system, hiding internal complexity from the user. Users interact only with the CLI commands.

A design approach where the primary way to interact with the software is through a command-line interface (typing commands in a terminal), rather than a graphical user interface.

A Python library for building command-line interfaces with minimal boilerplate. It handles argument parsing, command grouping, and help text generation.

A design pattern that allows treating individual objects and groups of objects uniformly. The Part hierarchy lets you handle a single text part or a complex message with multiple parts the same way.

Numerical vector representations of text that capture semantic meaning, used for tasks like similarity search and clustering. They convert words or sentences into lists of numbers.

A design pattern that provides an interface for creating objects without specifying their exact class. The get_models_with_aliases function creates the right model instance based on a name.

A design pattern that isolates core business logic from external systems (databases, APIs, UIs) using ports and adapters, making the core testable and swappable. This project explicitly does not use it.

A design pattern where an object (the subject) maintains a list of dependents (observers) and notifies them of state changes. The pluggy hook system implements this for plugin notifications.

A Python library that enables a plugin system by allowing plugins to register hooks that the host application calls at specific points. It is the backbone of this project's extensibility.

A software structure that allows external code (plugins) to add or modify features without changing the core codebase. Plugins hook into predefined extension points.

A software design where the core system provides essential functionality and defines extension points, while plugins add specialized features without modifying the core.

A design principle where interfaces (ports) are defined for external interactions, and concrete implementations (adapters) are written separately. This allows swapping databases or APIs without changing core logic.

A Python library for data validation and settings management using Python type annotations. It ensures that data conforms to defined schemas and provides automatic serialization.

The process of converting an object to a format (like JSON) for storage or transmission, and later reconstructing the original object from that format without losing information.

An architectural layer that contains business logic and coordinates operations between different parts of an application, sitting between the user interface and data access code.

A mechanism in Python's packaging system that allows packages to advertise plugins or extensions. Other tools can discover and load these plugins automatically at runtime.

A Python library that provides convenient methods for creating, querying, and managing SQLite databases. It simplifies database operations like inserting rows and running migrations.

Using the SQLite database engine to store and retrieve data persistently. SQLite is a lightweight, file-based database that requires no separate server process.

An object that creates other objects without remembering any previous interactions. Each call to the factory is independent and does not rely on stored state.

A design pattern that defines a family of interchangeable algorithms, allowing the client to choose which one to use at runtime. Here, different LLM providers are strategies for generating responses.

A technique where data is sent in small chunks as it becomes available, rather than waiting for the entire response. For LLMs, this means showing tokens one by one as they are generated.

LLM responses formatted according to a predefined schema (e.g., JSON), rather than free-form text, making them easier for programs to parse and use.

A design pattern that defines the skeleton of an algorithm in a base class, letting subclasses override specific steps without changing the overall structure. The Response class uses this for streaming.

The ability for an LLM to request execution of external functions (like searching a database or running code) and receive the results to incorporate into its response.