bee
Bee is an AI, easy and high efficiency ORM framework,support JDBC,Cassandra,Mongodb,Sharding,Android,HarmonyOS.
Stars: 627
Bee is an easy and high efficiency ORM framework that simplifies database operations by providing a simple interface and eliminating the need to write separate DAO code. It supports various features such as automatic filtering of properties, partial field queries, native statement pagination, JSON format results, sharding, multiple database support, and more. Bee also offers powerful functionalities like dynamic query conditions, transactions, complex queries, MongoDB ORM, cache management, and additional tools for generating distributed primary keys, reading Excel files, and more. The newest versions introduce enhancements like placeholder precompilation, default date sharding, ElasticSearch ORM support, and improved query capabilities.
README:
Easy for Stronger.
Bee is an ORM framework.
Bee is an easy and high efficiency ORM framework.
Coding Complexity is O(1),it means that Bee will do the Dao for you.
You don't need to write the Dao by yourself anymore.Help you to focus more on the development of business logic.
Good Feature: AI, Timesaving/Tasteful, Easy, Automatic (AiTeaSoft Style)
Newest version is:Bee V2.5.2 LTS(just 935k)
1.17.x LTS version:1.17.25
Sharding target: It is mainly transparent to business development and coding, with only a little sharding config.
Bee see:
https://github.com/automvc/bee
bee-ext:
https://github.com/automvc/bee-ext
Python ORM Bee:
https://github.com/automvc/BeePy
Easy to use:
- 1.Simple interface, convenient to use. The Suid interface provides four object-oriented methods corresponding to the SQL language's select, update, insert, and delete operations.
- 2.By using Bee, you no longer need to write separate DAO code. You can directly call Bee's API to perform operations on the database.
- 3.Convention-over-configuration: Javabean can no annotation, no xml.
- 4.Intelligent automatic filtering of null and empty string properties in entities eliminates the need for writing code to check for non-null values.
- 5.Easily implement partial field queries and native statement pagination.
- 6.Supports returning query results in JSON format; supports chaining.
- 7.Supports Sharding, both database and table Sharding; database-only Sharding; table-only Sharding; and read-write separation. This functionality is transparent to existing code and does not require additional coding.
- 8.Easily extendable with multiple database support (MySQL, MariaDB, Oracle, H2, SQLite, PostgreSQL, SQL Server, Access, Kingbase, Dameng, etc.), and theoretically supports any database supported by JDBC. Additionally, supports Android and Harmony.
- 9.Additional database pagination support for: MsAccess, Cubrid, HSQL, Derby, Firebird, etc.
- 10.Multiple databases can be used simultaneously (e.g., MySQL, Oracle, SQL Server).
Automatic, powerful:
- 11.Dynamic/arbitrary combination of query conditions without the need to prepare DAO interfaces in advance. New query requirements can be handled without modifying or adding interfaces.
- 12.Supports transactions, using the same connection for multiple ORM operations, FOR UPDATE, batch processing, executing native SQL statements, and stored procedures.
- 13.Supports object-oriented complex queries, multi-table queries (no N+1 problem), and supports one-to-one, one-to-many, many-to-one, and many-to-many relationships. The result structure can differ based on whether the sub-table uses List;multi-table association update, insert, and delete(2.1.8).
- 14.MongoDB ORM and support for MongoDB Sharding.
- 15.Supports register, interceptor, multi-tenancy, and custom TypeHandlers for handling ResultSet results in queries. SetParaTypeConvert converts PreparedStatement parameter types.
- 16.Custom dynamic SQL tags, such as @in, @toIsNULL1, @toIsNULL2, , . Allows dynamic SQL, converting lists into statements like in (1,2,3) without requiring foreach loops. Batch insertion also does not require foreach.
- 17.Complex query can be automatically parsed by the frontend and backend.
- 18.L1 cache, simple in concept and powerful in function; L1 cache can also be fine tuned like the JVM; Support updatable long-term cache list and update configuration table without restart. Inherently resistant to cache penetration. L2 cache extension support; Redis L2 cache support.
- 19.No third-party plugin dependencies; can be used with zero configuration.
- 20.High performance: close to the speed of JDBC; small file size: Bee V1.17.25 is only 520k, V2.5.2 is only 935k.
Assist function: -
- Provides a naturally simple solution for generating distributed primary keys: generates globally unique, monotonically increasing (within a worker ID) numeric IDs in a distributed environment.
- 22.Supports automatic generation of Javabean corresponding to tables(support Swagger), creating tables based on Javabean, and automatically generating backend Javaweb code based on templates. Can print executable SQL statements without placeholders for easy debugging. Supports generating SQL scripts in JSON format.
- 23.Supports reading Excel files and importing data into the database; simple operations. Supports generating database tables from Excel configurations.
- 24.Stream tool class StreamUtil;DateUtil date conversion, judge date format, calculate age.
- 25.Rich annotation support: PrimaryKey, Column, Datetime, Createtime, Updatetime; JustFetch, ReplaceInto (MySQL), Dict, DictI18n,GridFs, etc.
- 26.Use entity name _F (automatically generated) to reference entity field names, e.g., Users_F.name or in SuidRichExt interface using the format Users::getName.
2.5.2.1 New Year
- MongoDB update,delete,deleteById support for sharding
- MongoDB modify sharding cache enhance
- MongoDB index support for sharding
- add ShardingFullOpTemplate
- ObjSQLRich(SuidRich) add selectByTemplate for select
2.5.2.2 - fixed bug for MongodbShardingDdlEngine
- record and print sql execute time
bee.osql.showSqlExecuteTime=true
bee.osql.minSqlExecuteTime=0
8.use CQRS(Command Query Responsibility Segregation) operate database 2.5.2.6 - open some config in Honeyconfig as default
openEntityCanExtend = true
showSQL = true
showShardingSQL = true
showSqlExecuteTime = true
minSqlExecuteTime = 5; //ms - column allow use keyword
#there is a switch for it, default is true
bee.osql.naming.allowKeyWordInColumn=true
#define for append if bee do not contain them
bee.osql.naming.sqlKeyWordInColumn - separate logger; initialize config independently first
- BeeSimpleDataSourceBuilder is compatible with different style configurations
- GenFiles support genFileViaStream
- Genbean:update genFieldFile,toString, add method setUpperFieldNameInFieldFile
- update DoNotSetTabShadngValue tip message(Sharding insert need set the sharding value)
- SuidRich selectById,deleteById support sharding
- Condition support clone
- fixed bug:
sharding select all(no paging)
sharding modify cache
1.MySQL
2.Oracle
3.SQL Server
4.MariaDB
5.H2
6.SQLite
7.PostgreSQL
8.MS Access
9.Kingbase
10.DM
11.OceanBase
12.Cubrid,HSQL,Derby,Firebird
13.Other DB that support JDBC
NOSQL:
14.Mongodb
15.ElasticSearch
16.Cassandra
Mobile environment (database):
17.Android
18.Harmony
Test Evn : Local windows.
DB: MySQL (Version 5.6.24).
Test point: Batch Insert;Paging Select; Transaction(update and select).
Batch Insert(unit: ms) |
|||||
| 5k | 1w | 2w | 5w | 10w | |
| Bee | 529.00 | 458.33 | 550.00 | 1315.67 | 4056.67 |
| MyBatis | 1193 | 713 | 1292.67 | 1824.33 | Exception |
Paging Select(unit: ms) |
|||||
| 20 | 50 | 100 | 200 | 500 | |
| Bee | 17.33 | 58.67 | 52.33 | 38.33 | 57.33 |
| MyBatis | 314.33 | 446.00 | 1546.00 | 2294.33 | 6216.67 |
Transaction(update and select) (unit: ms) |
|||||
| 20 | 50 | 100 | 200 | 500 | |
| Bee | 1089.00 | 70.00 | 84.00 | 161.33 | 31509.33 |
| MyBatis | 1144 | 35 | 79.67 | 146.00 | 32155.33 |
Bee need files
orm\compare\bee\service\BeeOrdersService.java
MyBatis need files
orm\compare\mybatis\service\MybatisOrdersService.java
orm\compare\mybatis\dao\OrdersDao.java
orm\compare\mybatis\dao\OrdersMapper.java
orm\compare\mybatis\dao\impl\OrdersDaoImpl.java
common,Javabean and Service interface:
Orders.java
OrdersService.java
Performance comparison data of Bee application in app development
Operate 10000 records, and the use time comparison is as follows.
Operate 10000 records(unit: ms) |
|||
| insert | query | delete | |
| greenDao(Android) | 104666 | 600 | 47 |
| Bee(Android 8.1) | 747 | 184 | 25 |
| Bee(HarmonyOS P40 Pro simulator) | 339 | 143 | 2 |
<dependency>
<groupId>org.teasoft</groupId>
<artifactId>bee-all</artifactId>
<version>2.5.2</version>
</dependency>
<!-- Mysql config.You need change it to the real database config. -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
<scope>runtime</scope>
</dependency>Gradle
implementation group: 'org.teasoft', name: 'bee-all', version: '2.5.2'
//Gradle(Short)
implementation 'org.teasoft:bee-all:2.5.2'eg:
Create one database,default name is bee.
Create the tables and init the data by run the init-data(user-orders)-mysql.sql file(it is mysql sql script).
If no the bee.properties file, you can create it by yourself.
#bee.databaseName=MySQL
bee.db.dbName=MySQL
bee.db.driverName = com.mysql.jdbc.Driver
#bee.db.url =jdbc:mysql://localhost:3306/bee?characterEncoding=UTF-8
bee.db.url =jdbc:mysql://127.0.0.1:3306/bee?characterEncoding=UTF-8&useSSL=false
bee.db.username = root
bee.db.password =
#print log
bee.osql.showSQL=true
bee.osql.showSql.showType=true
bee.osql.showSql.showExecutableSql=true
# since 2.1.7 sqlFormat=true,will format the executable sql
bee.osql.showSql.sqlFormat=false
#log4j>slf4j>log4j2>androidLog>harmonyLog>systemLogger>fileLogger>noLogging>jdkLog>commonsLog
bee.osql.loggerType=systemLogger
Orders(Javabean)
Auto Genernate Javabean
import java.math.BigDecimal;
import java.util.List;
import org.teasoft.bee.osql.BeeException;
import org.teasoft.bee.osql.Suid;
import org.teasoft.honey.osql.core.BeeFactoryHelper;
import org.teasoft.honey.osql.core.Logger;
/**
* @author Kingstar
* @since 1.0
*/
public class SuidExamEN {
public static void main(String[] args) {
try {
Suid suid = BeeFactoryHelper.getSuid();
Orders orders1 = new Orders();//need gen the Javabean
orders1.setId(100001L);
orders1.setName("Bee(ORM Framework)");
List<Orders> list1 = suid.select(orders1); // 1. select
for (int i = 0; i < list1.size(); i++) {
Logger.info(list1.get(i).toString());
}
//Condition condition=BF.getCondition(); // The SuidRich interface has many methods with the Condition parameter
//condition.op(Orders_F.userid, Op.ge, 0); // userid>=0
//Op supports: =,>,<,>=,<=,!=, Like, in, not in, etc
orders1.setName("Bee(ORM Framework)");
int updateNum = suid.update(orders1); //2. update
Logger.info("update record:" + updateNum);
Orders orders2 = new Orders();
orders2.setUserid("bee");
orders2.setName("Bee(ORM Framework)");
orders2.setTotal(new BigDecimal("91.99"));
orders2.setRemark(""); // empty String test
int insertNum = suid.insert(orders2); // 3. insert
Logger.info("insert record:" + insertNum);
int deleteNum = suid.delete(orders2); // 4. delete
Logger.info("delete record:" + deleteNum);
} catch (BeeException e) {
Logger.error("In SuidExamEN (BeeException):" + e.getMessage());
//e.printStackTrace();
} catch (Exception e) {
Logger.error("In SuidExamEN (Exception):" + e.getMessage());
//e.printStackTrace();
}
}
}
// notice: this is just a simple sample. Bee suport transaction,paging,complicate select,slect json,and so on. bee.db.isAndroid=true
bee.db.androidDbName=account.db
bee.db.androidDbVersion=1
bee.osql.loggerType=androidLog
#turn on query result field type conversion, and more types will be supported
bee.osql.openFieldTypeHandler=true
#If you are allowed to delete and update the whole table, you need to remove the comments
#bee.osql.notDeleteWholeRecords=false
#bee.osql.notUpdateWholeRecords=falsepublic class YourAppCreateAndUpgrade implements CreateAndUpgrade{
@Override
public void onCreate() {
// You can create tables in an object-oriented way
Ddl.createTable(new Orders(), false);
Ddl.createTable(new TestUser(), false);
}
@Override
public void onUpgrade(int oldVersion, int newVersion) {
if(newVersion==2) {
Ddl.createTable(new LeafAlloc(), true);
Log.i("onUpgrade", "你在没有卸载的情况下，在线更新到版本:"+newVersion);
}
}
}
Configure android:name to BeeApplication in AndroidManifest.xml file.
package com.aiteasoft.util;
import org.teasoft.bee.android.CreateAndUpgradeRegistry;
import org.teasoft.beex.android.ApplicationRegistry;
public class BeeApplication extends Application {
private static Context context;
@Override
public void onCreate() {
ApplicationRegistry.register(this);//注册上下文
CreateAndUpgradeRegistry.register(YourAppCreateAndUpgrade.class);
}
}
// 并在AndroidManifest.xml,配置android:name为BeeApplication
<application
android:icon="@drawable/appicon"
android:label="@string/app_name"
android:name="com.aiteasoft.util.BeeApplication"
>Suid suid=BF.getSuid();
List<Orders> list = suid.select(new Orders()); Performance comparison data of Bee application in app development
Operate 10000 records, and the use time comparison is as follows.
Operate 10000 records(unit: ms) |
|||
| insert | query | delete | |
| greenDao(Android) | 104666 | 600 | 47 |
| Bee(Android 8.1) | 747 | 184 | 25 |
| Bee(HarmonyOS P40 Pro simulator) | 339 | 143 | 2 |
V2.1
Let Java more quicker programming than php and Rails.
Faster development of new combinations for Java Web：
Bee+Spring+SpringMVC
Faster development of new combinations for Spring Cloud microservices：
Bee + Spring Boot
Rapid Application Code Generation Platform--AiTea Soft made in China!
...
API-V1.17.x(Newest) SourceCode contain bee-1.17 CN & EN API,bee-1.17 CN SourceCode
API-V2.x(Newest) bee-2.5.2 EN API
Author's email: [email protected]
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for bee
Similar Open Source Tools
bee
Bee is an easy and high efficiency ORM framework that simplifies database operations by providing a simple interface and eliminating the need to write separate DAO code. It supports various features such as automatic filtering of properties, partial field queries, native statement pagination, JSON format results, sharding, multiple database support, and more. Bee also offers powerful functionalities like dynamic query conditions, transactions, complex queries, MongoDB ORM, cache management, and additional tools for generating distributed primary keys, reading Excel files, and more. The newest versions introduce enhancements like placeholder precompilation, default date sharding, ElasticSearch ORM support, and improved query capabilities.
honey
Bee is an ORM framework that provides easy and high-efficiency database operations, allowing developers to focus on business logic development. It supports various databases and features like automatic filtering, partial field queries, pagination, and JSON format results. Bee also offers advanced functionalities like sharding, transactions, complex queries, and MongoDB ORM. The tool is designed for rapid application development in Java, offering faster development for Java Web and Spring Cloud microservices. The Enterprise Edition provides additional features like financial computing support, automatic value insertion, desensitization, dictionary value conversion, multi-tenancy, and more.
CrackSQL
CrackSQL is a powerful SQL dialect translation tool that integrates rule-based strategies with large language models (LLMs) for high accuracy. It enables seamless conversion between dialects (e.g., PostgreSQL → MySQL) with flexible access through Python API, command line, and web interface. The tool supports extensive dialect compatibility, precision & advanced processing, and versatile access & integration. It offers three modes for dialect translation and demonstrates high translation accuracy over collected benchmarks. Users can deploy CrackSQL using PyPI package installation or source code installation methods. The tool can be extended to support additional syntax, new dialects, and improve translation efficiency. The project is actively maintained and welcomes contributions from the community.
DB-GPT
DB-GPT is a personal database administrator that can solve database problems by reading documents, using various tools, and writing analysis reports. It is currently undergoing an upgrade. **Features:** * **Online Demo:** * Import documents into the knowledge base * Utilize the knowledge base for well-founded Q&A and diagnosis analysis of abnormal alarms * Send feedbacks to refine the intermediate diagnosis results * Edit the diagnosis result * Browse all historical diagnosis results, used metrics, and detailed diagnosis processes * **Language Support:** * English (default) * Chinese (add "language: zh" in config.yaml) * **New Frontend:** * Knowledgebase + Chat Q&A + Diagnosis + Report Replay * **Extreme Speed Version for localized llms:** * 4-bit quantized LLM (reducing inference time by 1/3) * vllm for fast inference (qwen) * Tiny LLM * **Multi-path extraction of document knowledge:** * Vector database (ChromaDB) * RESTful Search Engine (Elasticsearch) * **Expert prompt generation using document knowledge** * **Upgrade the LLM-based diagnosis mechanism:** * Task Dispatching -> Concurrent Diagnosis -> Cross Review -> Report Generation * Synchronous Concurrency Mechanism during LLM inference * **Support monitoring and optimization tools in multiple levels:** * Monitoring metrics (Prometheus) * Flame graph in code level * Diagnosis knowledge retrieval (dbmind) * Logical query transformations (Calcite) * Index optimization algorithms (for PostgreSQL) * Physical operator hints (for PostgreSQL) * Backup and Point-in-time Recovery (Pigsty) * **Continuously updated papers and experimental reports** This project is constantly evolving with new features. Don't forget to star ⭐ and watch 👀 to stay up to date.
kernel-memory
Kernel Memory (KM) is a multi-modal AI Service specialized in the efficient indexing of datasets through custom continuous data hybrid pipelines, with support for Retrieval Augmented Generation (RAG), synthetic memory, prompt engineering, and custom semantic memory processing. KM is available as a Web Service, as a Docker container, a Plugin for ChatGPT/Copilot/Semantic Kernel, and as a .NET library for embedded applications. Utilizing advanced embeddings and LLMs, the system enables Natural Language querying for obtaining answers from the indexed data, complete with citations and links to the original sources. Designed for seamless integration as a Plugin with Semantic Kernel, Microsoft Copilot and ChatGPT, Kernel Memory enhances data-driven features in applications built for most popular AI platforms.
datachain
DataChain is an open-source Python library for processing and curating unstructured data at scale. It supports AI-driven data curation using local ML models and LLM APIs, handles large datasets, and is Python-friendly with Pydantic objects. It excels at optimizing batch operations and is designed for offline data processing, curation, and ETL. Typical use cases include Computer Vision data curation, LLM analytics, and validation.
vision-parse
Vision Parse is a tool that leverages Vision Language Models to parse PDF documents into beautifully formatted markdown content. It offers smart content extraction, content formatting, multi-LLM support, PDF document support, and local model hosting using Ollama. Users can easily convert PDFs to markdown with high precision and preserve document hierarchy and styling. The tool supports multiple Vision LLM providers like OpenAI, LLama, and Gemini for accuracy and speed, making document processing efficient and effortless.
rl
TorchRL is an open-source Reinforcement Learning (RL) library for PyTorch. It provides pytorch and **python-first** , low and high level abstractions for RL that are intended to be **efficient** , **modular** , **documented** and properly **tested**. The code is aimed at supporting research in RL. Most of it is written in python in a highly modular way, such that researchers can easily swap components, transform them or write new ones with little effort.
datachain
DataChain is a Python-based AI-data warehouse for transforming and analyzing unstructured data like images, audio, videos, text, and PDFs. It integrates with external storage to process data efficiently without duplication and manages metadata for easy querying. Use cases include ETL, analytics, versioning, and incremental processing. Key features include multimodal dataset versioning, Python-friendly operations, data enrichment, and processing. The tool allows for generating metadata using AI models, filtering, joining, and grouping datasets, and performing high-performance vectorized operations.
typedai
TypedAI is a TypeScript-first AI platform designed for developers to create and run autonomous AI agents, LLM based workflows, and chatbots. It offers advanced autonomous agents, software developer agents, pull request code review agent, AI chat interface, Slack chatbot, and supports various LLM services. The platform features configurable Human-in-the-loop settings, functional callable tools/integrations, CLI and Web UI interface, and can be run locally or deployed on the cloud with multi-user/SSO support. It leverages the Python AI ecosystem through executing Python scripts/packages and provides flexible run/deploy options like single user mode, Firestore & Cloud Run deployment, and multi-user SSO enterprise deployment. TypedAI also includes UI examples, code examples, and automated LLM function schemas for seamless development and execution of AI workflows.
pixeltable
Pixeltable is a Python library designed for ML Engineers and Data Scientists to focus on exploration, modeling, and app development without the need to handle data plumbing. It provides a declarative interface for working with text, images, embeddings, and video, enabling users to store, transform, index, and iterate on data within a single table interface. Pixeltable is persistent, acting as a database unlike in-memory Python libraries such as Pandas. It offers features like data storage and versioning, combined data and model lineage, indexing, orchestration of multimodal workloads, incremental updates, and automatic production-ready code generation. The tool emphasizes transparency, reproducibility, cost-saving through incremental data changes, and seamless integration with existing Python code and libraries.
sophia
Sophia is an open-source TypeScript platform designed for autonomous AI agents and LLM based workflows. It aims to automate processes, review code, assist with refactorings, and support various integrations. The platform offers features like advanced autonomous agents, reasoning/planning inspired by Google's Self-Discover paper, memory and function call history, adaptive iterative planning, and more. Sophia supports multiple LLMs/services, CLI and web interface, human-in-the-loop interactions, flexible deployment options, observability with OpenTelemetry tracing, and specific agents for code editing, software engineering, and code review. It provides a flexible platform for the TypeScript community to expand and support various use cases and integrations.
UnrealGenAISupport
The Unreal Engine Generative AI Support Plugin is a tool designed to integrate various cutting-edge LLM/GenAI models into Unreal Engine for game development. It aims to simplify the process of using AI models for game development tasks, such as controlling scene objects, generating blueprints, running Python scripts, and more. The plugin currently supports models from organizations like OpenAI, Anthropic, XAI, Google Gemini, Meta AI, Deepseek, and Baidu. It provides features like API support, model control, generative AI capabilities, UI generation, project file management, and more. The plugin is still under development but offers a promising solution for integrating AI models into game development workflows.
obsei
Obsei is an open-source, low-code, AI powered automation tool that consists of an Observer to collect unstructured data from various sources, an Analyzer to analyze the collected data with various AI tasks, and an Informer to send analyzed data to various destinations. The tool is suitable for scheduled jobs or serverless applications as all Observers can store their state in databases. Obsei is still in alpha stage, so caution is advised when using it in production. The tool can be used for social listening, alerting/notification, automatic customer issue creation, extraction of deeper insights from feedbacks, market research, dataset creation for various AI tasks, and more based on creativity.
vecs
vecs is a Python client for managing and querying vector stores in PostgreSQL with the pgvector extension. It allows users to create collections of vectors with associated metadata, index the collections for fast search performance, and query the collections based on specified filters. The tool simplifies the process of working with vector data in a PostgreSQL database, making it easier to store, retrieve, and analyze vector information.
TornadoVM
TornadoVM is a plug-in to OpenJDK and GraalVM that allows programmers to automatically run Java programs on heterogeneous hardware. TornadoVM targets OpenCL, PTX and SPIR-V compatible devices which include multi-core CPUs, dedicated GPUs (Intel, NVIDIA, AMD), integrated GPUs (Intel HD Graphics and ARM Mali), and FPGAs (Intel and Xilinx).
For similar tasks
bee
Bee is an easy and high efficiency ORM framework that simplifies database operations by providing a simple interface and eliminating the need to write separate DAO code. It supports various features such as automatic filtering of properties, partial field queries, native statement pagination, JSON format results, sharding, multiple database support, and more. Bee also offers powerful functionalities like dynamic query conditions, transactions, complex queries, MongoDB ORM, cache management, and additional tools for generating distributed primary keys, reading Excel files, and more. The newest versions introduce enhancements like placeholder precompilation, default date sharding, ElasticSearch ORM support, and improved query capabilities.
jeecg-boot-starter
The jeecg-boot-starter is a module that simplifies projects and facilitates maintenance by extracting the starter module from jeecg-boot. It includes various sub-modules for common classes, cloud services, job scheduling, distributed locking, messaging middleware, distributed transactions, sharding databases, and MongoDB.
HighPerfLLMs2024
High Performance LLMs 2024 is a comprehensive course focused on building a high-performance Large Language Model (LLM) from scratch using Jax. The course covers various aspects such as training, inference, roofline analysis, compilation, sharding, profiling, and optimization techniques. Participants will gain a deep understanding of Jax and learn how to design high-performance computing systems that operate close to their physical limits.
For similar jobs
aiomcache
aiomcache is a Python library that provides an asyncio (PEP 3156) interface to work with memcached. It allows users to interact with memcached servers asynchronously, making it suitable for high-performance applications that require non-blocking I/O operations. The library offers similar functionality to other memcache clients and includes features like setting and getting values, multi-get operations, and deleting keys. Version 0.8 introduces the `FlagClient` class, which enables users to register callbacks for setting or processing flags, providing additional flexibility and customization options for working with memcached servers.
aiolimiter
An efficient implementation of a rate limiter for asyncio using the Leaky bucket algorithm, providing precise control over the rate a code section can be entered. It allows for limiting the number of concurrent entries within a specified time window, ensuring that a section of code is executed a maximum number of times in that period.
bee
Bee is an easy and high efficiency ORM framework that simplifies database operations by providing a simple interface and eliminating the need to write separate DAO code. It supports various features such as automatic filtering of properties, partial field queries, native statement pagination, JSON format results, sharding, multiple database support, and more. Bee also offers powerful functionalities like dynamic query conditions, transactions, complex queries, MongoDB ORM, cache management, and additional tools for generating distributed primary keys, reading Excel files, and more. The newest versions introduce enhancements like placeholder precompilation, default date sharding, ElasticSearch ORM support, and improved query capabilities.
claude-api
claude-api is a web conversation library for ClaudeAI implemented in GoLang. It provides functionalities to interact with ClaudeAI for web-based conversations. Users can easily integrate this library into their Go projects to enable chatbot capabilities and handle conversations with ClaudeAI. The library includes features for sending messages, receiving responses, and managing chat sessions, making it a valuable tool for developers looking to incorporate AI-powered chatbots into their applications.
aide
Aide is a code-first API documentation and utility library for Rust, along with other related utility crates for web-servers. It provides tools for creating API documentation and handling JSON request validation. The repository contains multiple crates that offer drop-in replacements for existing libraries, ensuring compatibility with Aide. Contributions are welcome, and the code is dual licensed under MIT and Apache-2.0. If Aide does not meet your requirements, you can explore similar libraries like paperclip, utoipa, and okapi.
amadeus-java
Amadeus Java SDK provides a rich set of APIs for the travel industry, allowing developers to access various functionalities such as flight search, booking, airport information, and more. The SDK simplifies interaction with the Amadeus API by providing self-contained code examples and detailed documentation. Developers can easily make API calls, handle responses, and utilize features like pagination and logging. The SDK supports various endpoints for tasks like flight search, booking management, airport information retrieval, and travel analytics. It also offers functionalities for hotel search, booking, and sentiment analysis. Overall, the Amadeus Java SDK is a comprehensive tool for integrating Amadeus APIs into Java applications.
rig
Rig is a Rust library designed for building scalable, modular, and user-friendly applications powered by large language models (LLMs). It provides full support for LLM completion and embedding workflows, offers simple yet powerful abstractions for LLM providers like OpenAI and Cohere, as well as vector stores such as MongoDB and in-memory storage. With Rig, users can easily integrate LLMs into their applications with minimal boilerplate code.
celery-aio-pool
Celery AsyncIO Pool is a free software tool licensed under GNU Affero General Public License v3+. It provides an AsyncIO worker pool for Celery, enabling users to leverage the power of AsyncIO in their Celery applications. The tool allows for easy installation using Poetry, pip, or directly from GitHub. Users can configure Celery to use the AsyncIO pool provided by celery-aio-pool, or they can wait for the upcoming support for out-of-tree worker pools in Celery 5.3. The tool is actively maintained and welcomes contributions from the community.