mergekit | leaping | |
---|---|---|
6 | 4 | |
3,521 | 247 | |
18.7% | 17.0% | |
9.2 | 2.9 | |
5 days ago | about 1 month ago | |
Python | Python | |
GNU Lesser General Public License v3.0 only | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
mergekit
-
Language Models Are Super Mario: Absorbing Abilities from Homologous Models
For others like me who’d not heard of merging before, this seems to be one tool[0] (there may be others)
[0] https://github.com/arcee-ai/mergekit
- FLaNK AI Weekly 25 March 2025
- Tools for merging pretrained large language models
-
Blending Is All You Need: Cheaper, Better Alternative to Trillion-Parameters LLM
mergekit is the tool you need to do this
https://github.com/cg123/mergekit
-
Iambe-RP-20b: An uncensored L2 Frankenstein model directly trained with RP-oriented cDPO
I actually asked the creator of mergekit a question here. In his response, I learned how to use task_arithmetic to isolate the deltas. One could, in theory, use WANDA on that model from the second example, then merge it back into another model. However, that's firmly past the frontier of what has been tried, so experimentation might be messy.
-
LLMs cannot find reasoning errors, but can correct them
Ah, actually reviewing that more closely I found a link to it in the acknowledgements.
https://github.com/cg123/mergekit
leaping
- FLaNK AI Weekly 25 March 2025
-
Show HN: Leaping – Debug Python tests instantly with an LLM debugger
Oof, I'm sorry to hear that - I don't think we had any Django projects in the set of projects we were testing this out on. I just filed an issue here and hopefully fix it asap - https://github.com/leapingio/leaping/issues/2
-
Show HN: Leaping – Open-source debugging with LLMs
Show HN: Leaping - Open-source debugging with LLMs
Hi HN! We’re Adrien and Kanav. We met at our previous job, where we spent about a third of our life combating a constant firehose of bugs. In the hope of reducing this pain for others in the future, we’re working on automating debugging.
We started by capturing information from running applications to then ‘replay’ relevant sessions later. Our approach for Python involved extensive monkey patching: we’d use OpenTelemetry-style instrumentation to hook into the request/response lifecycle, and capture anything non-deterministic (random, time, database/third-party API calls, etc.). We would then run your code again, mocking out the non-determinism with the captured values from production, which would let you fix production bugs with the local debugger experience. You might recognize this as a variant of omniscient debugging. We think it was a nifty idea, but we couldn’t get past the performance overhead/security concerns.
Approaching the problem differently, we thought - could we not just grab a stack trace and sort of “figure it out” from there? Whether that’s possible in the general case is up for debate – but we think that eventually, yes. The argument goes as follows: developers can solve bugs not because they are particularly clever or experienced (though it helps), but rather because they are willing to spend enough time coming up with increasingly informed hypotheses (“was the variable set incorrectly inside of this function?”) that they can test out in tight feedback loops (“let me print out the variable before and after the function call”). We wondered: with the proper context and guidance, why couldn’t an LLM do the same?
Over the last few weeks, we’ve been working on an approach that emulates the failing test approach to debugging, where you first reproduce the error in a failing test, then fix the source code, and finally run the test again to make sure it passes. Concretely, we take a stack trace, and start by simply re-running the function that failed. We then report the result back to the LLM, add relevant source code to the context window (with Tree-sitter and LSP), and prompt the AI for a code change that will get us closer to reproducing the bug. We apply those changes, re-run the script, and keep looping until we get the same bug as the original stack trace. Then the LLM formulates a root cause, generates a fix, we run the code again - and if the bug goes away, we call it a day. We’re also looking into letting the LLM interact with a pdb shell, as well as implementing RAG for better context fetching. One thing that excites us about generating a functioning test case with a step-by-step explanation for the fix is that results are somewhat grounded in reality, making hallucinations/confabulations less likely.
Here’s a 50 second demo of how this approach fares on a (perhaps contrived) error: https://www.loom.com/share/a54c981536a54d3c9c269d8356ea0d51?sid=aeafd2d1-9b86-43ad-83a6-b1062aa1bb50
We’re working on releasing a self-hosted Python version in the next few weeks on our GitHub repo: https://github.com/leapingio/leaping (right now it’s just the demo source code). This is just the first step towards a larger goal, so we’d love to hear any and all feedback/questions, or feel free to shoot me an email at [email protected]!
What are some alternatives?
Finetune_LLMs - Repo for fine-tuning Casual LLMs
spring-ai - An Application Framework for AI Engineering
xTuring - Build, customize and control you own LLMs. From data pre-processing to fine-tuning, xTuring provides an easy way to personalize open-source LLMs. Join our discord community: https://discord.gg/TgHXuSJEk6
LLMLingua - To speed up LLMs' inference and enhance LLM's perceive of key information, compress the prompt and KV-Cache, which achieves up to 20x compression with minimal performance loss.
task_vectors - Editing Models with Task Arithmetic
difftastic - a structural diff that understands syntax 🟥🟩
makeMoE - From scratch implementation of a sparse mixture of experts language model inspired by Andrej Karpathy's makemore :)
LaVague - Large Action Model framework to turn natural language into browser actions
examples - This repository will contain examples of use cases that utilize Decodable streaming solution
Chinese-LLaMA-Alpaca - 中文LLaMA&Alpaca大语言模型+本地CPU/GPU训练部署 (Chinese LLaMA & Alpaca LLMs)
pretzelai - Open-source, browser-local data exploration using DuckDB-Wasm and PRQL