Apple Notes ships on all MacOS and iOS devices, and is a quick way to take notes; I have notes that I took 10+ years ago, that have survived many device upgrades.
Notes has many features that makes it a lightweight knowledge management tool like ability to attach pictures directly from the phone, HTML tables, and most recently - Linking to other notes.
This has me wondering if Notes can be used a lightweight authoring tool for a website. However, notes supports only exporting single note to PDF, and nothing much else.
The first step to this is to export the content into a more web friendly format like HTML (or markdown, whence it can be converted to HTML easily).
The exported [notes] table contains HTML in the body column:
CREATE TABLE [notes] (
[id] TEXT PRIMARY KEY,
[created] TEXT,
[updated] TEXT,
[title] TEXT,
[body] TEXT
);
If one can build a MacOS native app that can directly publish the notes as webpages to a hosting service, then we can see the classic Desktop based web publishing make a come back in a small way.
At the least this NotesPublisher should have the following options:
Ray unifies task-parallel and actor programming models in a single dynamic task graph and employs a scalable architecture enabled by the global control store and a bottom-up distributed scheduler. The programming flexibility, high throughput, and low latencies simultaneously achieved by this architecture is particularly important for emerging artificial intelligence work- loads, which produce tasks diverse in their resource requirements, duration, and functionality.
Learning Ray by Max Pumperla, Edward Oakes, and Richard Liaw. ( PDF ).
In short, Ray sets up and manages clusters of computers so that you can run distributed tasks on them. A Ray Cluster consists of nodes that are connected to each other via a network. You program against the so-called driver, the program root, which lives on the head node. The driver can run jobs, a collection of tasks, that are run on the nodes in the cluster. Specifically, the individual tasks of a job are run on worker processes on worker nodes.
This cluster can also be local, on your laptop. The default number of worker processes is the number of CPUs available on your machine.
"I did not recruit extraordinary people. I recruited people who had extraordinary potential—and then I trained them." -- HGR
Hyman G. Rickover was an admiral in the United States Navy. He directed the original development of naval nuclear propulsion and controlled its operations for three decades as director of the U.S. Naval Reactors office.
I made one man responsible for his entire area of equipment—for design, production, maintenance, and contracting. If anything went wrong, I knew exactly at whom to point. -- HGR, via.
In the above thread:
Amazon has a name for it STO (single threaded owner) and STL (single threaded leader). Each initiative/service/project needs to formally have a named person as STO or a STL.
Release a common framework for evaluating the many different architectures of reward models, along with tools for visualization, training, and other analysis. We also release all data used in the evaluation, composed of text-score pairs for all inputs, to enable further data analysis on the properties of reward models.
Illustrate the differences between DPO and classifier-based reward models across a variety of datasets. DPO models, while more plentiful due to the method’s simplicity, fail to generalize to popular preference data test sets and present a higher variance in performance.
Chart the landscape of current state-of-the-art reward models. We showcase the scaling laws, the propensity to refuse (or not), the reasoning capabilities, and more for popular RMs.
Show the limitations of existing preference data test sets for evaluating these models, showcasing common pitfalls of RMs on subtle, but challenging instruction pairs (e.g. intentionally modified rejected responses, which superficially look high quality but answer the wrong prompt).
Current approaches commonly train reward models from human preferences, which may then be bottlenecked by human performance level, and secondly these separate frozen reward models cannot then learn to improve during LLM training. In this work, we study Self-Rewarding Language Models, where the language model itself is used via LLM-as-a-Judge prompting to provide its own rewards during training. We show that during Iterative DPO training that not only does instruction following ability improve, but also the ability to provide high-quality rewards to itself.
Self Play Fine Tuning (SPIN)
According to (Das 2024), (creator of premai, which is also a good overview of RHLF (Reinforcement Learning from Human Feedback), DPO (Direct Preference Optimization), IPO (Identify Preference Optimization), the propose Self-Play Fine-Tuning (SPIN) is a method designed to enhance the capabilities of Large Language Models (LLMs) through a unique self-improvement process that doesn't rely on additional human-annotated data -- (Chen et al. 2024)
Roe AI -- "AI for Risk, Compliance and Trust. Create AI workers to automate your risk operations." ^e9eac9
Stack-AI.com -- The No-Code Generative AI Platform. Deploy custom AI Assistants, Chatbots, and Workflow Automations to make your company 10x more efficient.
Ray.IO - Productionizing and scaling Python ML workload -- "Ray is an open-source unified compute framework that makes it easy to scale AI and Python workloads — from reinforcement learning to deep learning to tuning, and model serving." See presentationFlexible Distributed Python for Machine Learning. See also Ray
Cohere -- Optimized for enterprise generative AI,
search and discovery, and advanced retrieval.
modal labs -- Run generative AI models, large-scale batch jobs, job queues, and much more. Eg: host your own mistral model etc. "Bring your own code — we run the infrastructure."
With applications like - Q&A, Structured Extraction, Chat, Semantic Search, and Agents.
LLaMa Index
Taylor - API for Text Classification -- Proprietary text classifiers designed for speed. Classify all your text data in real time: every user SMS, every support ticket, and every document.
Agenthub -- "Automate any workflow with AI. Drag, drop, and deploy custom tools your business needs."
Hercules -- "Multi-Agent AI solutions that automate complex workflows. Transform complex workflows with Generative AI solutions built on the Hercules Platform."
Magick - Cutting-edge tools for AI creators - "Artificial Intelligence Development Environment (AIDE) is similar to existing tools you know, as well as platform agnostic, and open-source, allowing full control to always be in your hands."
Gumloop | AI Automation Framework "Drag, drop, and deploy custom tools your business needs. No AI expertise needed." ( previously AgentHub)
LLM API companies
Together AI -- offers Inference, fine-tuning, custom-models, and GPU Clusters. eg: $1.20/million tokens of Mixtral-8x22B (Apr 11, 2024) (login:github )
Deep Infra -- "Fast ML Inference, Simple API. Run the top AI models using a simple API, pay per use. Low cost, scalable and production ready infrastructure." $0.65/Million tokens
OpenPipe "Fine-Tuning for Developers", "Software engineers and data scientists use OpenPipe’s intuitive fine-tuning and monitoring services to decrease the cost and latency of their LLM operations. You can use OpenPipe to collect and analyze LLM logs, create fine-tuned models, and compare output from multiple models given the same input."
@OpenPipeAI makes fine-tuning a model a 1 hour project instead of months. And when a new better model drops it's a 5 minute project to fine-tune it and switch.
Xr0 is a verifier for C. It eliminates many stubborn instances of undefined behaviour, like use-after-frees, double frees, null pointer dereferences and the use of uninitialised memory.
Generate beautiful docs from your transcripts and unstructured information with a single command. A simple way to generate comprehensive, easy-to-skim docs from your meeting transcripts and large documents.
Large language models (LLMs) often generate content that contains factual errors when responding to fact-seeking prompts on open-ended topics.
This paper by Google Deepmind -- (Wei et al. 2024) -- proposes a method which they call Search-Augmented Factuality Evaluator (SAFE). SAFE utilizes an LLM to break down a long-form response into a set of individual facts and to evaluate the accuracy of each fact using a multi-step reasoning process comprising sending search queries to Google Search and determining whether a fact is supported by the search results. Furthermore, they propose extending F1 score as an aggregated metric for long-form factuality. To do so, they balance the percentage of supported facts in a response (precision) with the percentage of provided facts relative to a hyper-parameter representing a user's preferred response length (recall).
Create credible and powerful LLM apps, faster. TruLens is a software tool that helps you to objectively measure the quality and effectiveness of your LLM-based applications using feedback functions. Feedback functions help to programmatically evaluate the quality of inputs, outputs, and intermediate results, so that you can expedite and scale up experiment evaluation. Use it for a wide variety of use cases including question answering, summarization, retrieval-augmented generation, and agent-based applications.
MoscaicML was a startup acquired by Databricks in July 6, 2023 for $1.3B. In March 2024, they were behind the announcement of Databricks's new Foundation Model - DBRX
Composer is an open-source deep learning training library. Built on top of pytorch, this library makes it easier to implement distributed training workflows on large-scale clusters. Use Composer to speedup experimentation workflow if training neural networks of any size, including:
Admiral Hyman Rickover (1900-1986), the “Father of the Nuclear Navy,” was one of the most successful—and controversial- public managers of the 20th Century. His accomplishments are the stuff of legend. For example, in three short years, Rickover’s team designed and built the first nuclear submarine—the Nautilus—an amazing feat of engineering given that it involved the development of the first use of a controlled nuclear reactor. The Nautilus not only transformed submarine warfare, but also laid the groundwork for a whole fleet of nuclear aircraft carriers and cruisers (which was also built by Rickover and his team).
The text below is an excerpt from a speech Rickover delivered at Columbia University in 1982, in which he succinctly outlined his management philosophy. His determination, clarity of purpose, emphasis on developing his people, high standards, and willingness to give his people ownership of their work had to have been very inspiring. He had exceptionally high standards and was known to take some of these same strengths to extremes, however, which no doubt led to his reputation in some circles as being difficult to work for. On that cautionary note, GovLeaders.org is pleased to present Rickover’s own description of his management style.
As described in American Nations, our true regional fissures can be traced back to the contrasting ideals of the distinct European colonial cultures that first took root on the eastern and southern rims of what is now the United States, and then spread across much of the continent in mutually exclusive settlement bands, laying down the institutions, symbols and cultural norms later arrivals would encounter and, by and large, assimilate into. (Academically, this work is built on the foundations of the late cultural geographer Wilbur Zelinsky’s Doctrine of First Effective Settlement.)
The most precious, creative and innovative period in your life is the 10-year period around the age of 32. Plan your career path to use this precious 10-year period wisely and effectively to produce your greatest achievements in your life.
The pace of innovations and technology advances is getting faster and faster and is forcing everybody to compete fiercely at the Internet speed on the information super-highways. The highly productive and highly efficient workplace in USA is a pressure-cooker and a high-speed battleground for highly creative and dynamic young people to compete and to flourish.
However, when you get older, you should plan your career path and financial matter so that you can retire comfortably at the age of 55 or earlier to enjoy your long, happy and leisure retirement life into your golden age of 80s and beyond. In retirement, you can still enjoy some fun work of great interest to you and of great values to the society and the community, but at a part-time leisure pace on your own term.
On the other hand, if you are not able to get out of the pressure-cooker or the high-speed battleground at the age of 55 and “have” to keep on working very hard until the age of 65 or older before your retirement, then you probably will die within 18 months of retirement. By working very hard in the pressure cooker for 10 more years beyond the age of 55, you give up at least 20 years of your life span on average.
Self-Hosted Remote Development Environment Open source, self hosted with ease. It uses Devcontainers spec and scales from a single machine to a global fleet of servers.
Tiptap is an open source headless content editor and real-time collaboration framework to craft exactly the content experience you’d like to have – built for developers.
will be useful for having Notion like WYSIWYG editor experience
Sora is the first large-scale generalist video generation model that garnered significant attention across society. Since its launch by OpenAI in February 2024, no other video generation models have paralleled Sora's performance or its capacity to support a broad spectrum of video generation tasks. Additionally, there are only a few fully published video generation models, with the majority being closed-source. To address this gap, this paper proposes a new multi-agent framework Mora, which incorporates several advanced visual AI agents to replicate generalist video generation demonstrated by Sora.
Agentic systems are a category of advanced AI systems focused on autonomy and goal-directed behavior. They possess the following characteristics:
--
Agent Skills by Anthropic -- Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to do things more accurately and efficiently.
MAGIS: a novel LLM-based Multi-Agent framework for GitHub Issue reSolution, MAGIS, consisting of four kinds of agents customized for the software evolution: Manager, Repository Custodian, Developer, and Quality Assurance Engineer agents. This framework leverages the collaboration of various agents in the planning and coding process to unlock the potential of LLMs to resolve GitHub issues. In experiments, we employ the SWE-bench benchmark to compare MAGIS with popular LLMs, including GPT-3.5, GPT-4, and Claude-2.
In this paper, we present an innovative paradigm that leverages large language models (LLMs) throughout the entire software development process, streamlining and unifying key processes through natural language communication, thereby eliminating the need for specialized models at each phase. At the core of this paradigm lies ChatDev, a virtual chat-powered software development company that mirrors the established waterfall model, meticulously dividing the development process into four distinct chronological stages: designing, coding, testing, and documenting. Each stage engages a team of "software agents", such as programmers, code reviewers, and test engineers, fostering collaborative dialogue and facilitating a seamless workflow. The chat chain acts as a facilitator, breaking down each stage into atomic subtasks. This enables dual roles, allowing for proposing and validating solutions through context-aware communication, leading to efficient resolution of specific subtasks. The instrumental analysis of ChatDev highlights its remarkable efficacy in software generation, enabling the completion of the entire software development process in under seven minutes at a cost of less than one dollar. It not only identifies and alleviates potential vulnerabilities but also rectifies potential hallucinations while maintaining commendable efficiency and cost-effectiveness.
Ludic is a lightweight framework for building HTML pages with component approach similar to React. It is built to be used together with htmx.org so that developers don't need to write almost any JavaScript to create dynamic web services. It's potential can be leveraged together with its web framework which is a wrapper around powerful Starlette framework.
obsidiantools is a Python package for getting structured metadata about your Obsidian.md notes and analysing your vault. Complement your Obsidian workflows by getting metrics and detail about all your notes in one place through the widely-used Python data stack.
It's incredibly easy to explore structured data on your vault through this fluent interface. This is all the code you need to generate a vault object that stores all the data:
The Great Tables package is all about making it simple to produce nice-looking display tables. Display tables? Well yes, we are trying to distinguish between data tables (i.e., DataFrames) and those tables you’d find in a web page, a journal article, or in a magazine. Such tables can likewise be called presentation tables, summary tables, or just tables really. Here are some examples, ripped straight from the web:
Garnet from Microsoft is a redis protocol (RESP) compliant remote cache-store. Garnet is thread-scalable within a single node. It also supports sharded cluster execution, with replication, checkpointing, failover, and transactions. It can operate over main memory as well as tiered storage (such as SSD and Azure Storage). Garnet supports a rich API surface and a powerful extensibility model. one can use Garnet with unmodified Redis clientsavailable in most programming languages. Blog post - A brief history of Garnet
Dragonfly - The Fastest In-Memory Data Store "is a drop-in Redis replacement, designed to meet the performance and efficiency requirements of modern cloud-based applications. Organizations that switch to Dragonfly require less hardware and achieve dramatically improved data performance." - licensed under BSL 1.1
DiceDB -- an in-memory, real-time, and reactive database with Redis and SQL support optimized for modern hardware and building real-time applications by Arpit Bhayani.
Garnet is a redis protocol (RESP) compliant remote cache-store. Garnet is thread-scalable within a single node. It also supports sharded cluster execution, with replication, checkpointing, failover, and transactions. It can operate over main memory as well as tiered storage (such as SSD and Azure Storage). Garnet supports a rich API surface and a powerful extensibility model. one can use Garnet with unmodified Redis clientsavailable in most programming languages.
The concepts of the late US Air Force Colonel John R. Boyd have influenced military thought in profound ways, from the design of modern fighter aircraft to the tactics used by the US Marine Corps in both Gulf Wars. This paper describes the best known aspect of his strategic thought, the OODA “loop,” and how practitioners in war and business can use the loop to implement a framework that has proven successful since the time of Sun Tzu.
Boyd argued that the loop applies to companies, too. If you can "get inside the OODA loop" of your competitor, you have the advantage. By the time they even notice a market is there, you have identified an opportunity, gathered data, tried an approach, and learned from mistakes.
Zemblanity [via](https://x.com/abesorock/status/1769797163888832898); text taken from `vgr`.
There are many ways to exploit others' habits, but wrangling luck is perhaps the most powerful way. Wrangling luck effectively creates a sort of "competitive climate" comprising patterns of serendipity and
its opposite, zemblanity.
Competitive Climates
You're in a world where luck is the scarce resource, because there are more ways for things to go wrong than right. If you can direct more luck towards your- self and more misfortune towards your adversary, you've amplified the effectiveness of just about everything else you do.
In open competitive environments, luck is not just about die-rolls or card shuffles. It is a control variable. The control variable. In the overall game of life, your big goal is to drive serendipity towards yourself and its opposite, zemblanity (there, you learned a new word) towards your adversaries.
When luck is being consciously wrangled in a real-life game, winning feels like things miraculously going your way, things falling into place for you just
right, unreasonably out of proportion to your actions. This is serendipity.
By contrast, losing feels like an overpowering sense of doom and snowballing misfortunes out of proportion to your sins and stupidity. This is zemblanity.
In this work, we discuss building performant Multimodal Large Language Models (MLLMs). In particular, we study the importance of various architecture components and data choices. Through careful and comprehensive ablations of the image encoder, the vision language connector, and various pre-training data choices, we identified several crucial design lessons. For example, we demonstrate that for large-scale multimodal pre-training using a careful mix of image-caption, interleaved image-text, and text-only data is crucial for achieving state-of-the-art (SOTA) few-shot results across multiple benchmarks, compared to other published pre-training results. Further, we show that the image encoder together with image resolution and the image token count has substantial impact, while the vision-language connector design is of comparatively negligible importance. By scaling up the presented recipe, we build MM1, a family of multimodal models up to 30B parameters, consisting of both dense models and mixture-of-experts (MoE) variants, that are SOTA in pre-training metrics and achieve competitive performance after supervised fine-tuning on a range of established multimodal benchmarks. Thanks to large-scale pre-training, MM1 enjoys appealing properties such as enhanced in-context learning, and multi-image reasoning, enabling few-shot chain-of-thought prompting.
We compile content to syntax trees and syntax trees to content. We also provide hundreds of packages to work on the trees in between. You can build on the unified collective to make all kinds of interesting things.
When writing and talking, people sometimes pause to think. Although reasoning-focused works have often framed reasoning as a method of answering questions or completing agentic tasks, reasoning is implicit in almost all written text. For example, this applies to the steps not stated between the lines of a proof or to the theory of mind underlying a conversation. In the Self-Taught Reasoner (STaR, Zelikman et al. 2022), useful thinking is learned by inferring rationales from few-shot examples in question-answering and learning from those that lead to a correct answer. This is a highly constrained setting -- ideally, a language model could instead learn to infer unstated rationales in arbitrary text. We present Quiet-STaR, a generalization of STaR in which LMs learn to generate rationales at each token to explain future text, improving their predictions. We address key challenges, including 1) the computational cost of generating continuations, 2) the fact that the LM does not initially know how to generate or use internal thoughts, and 3) the need to predict beyond individual next tokens. To resolve these, we propose a tokenwise parallel sampling algorithm, using learnable tokens indicating a thought's start and end, and an extended teacher-forcing technique. Encouragingly, generated rationales disproportionately help model difficult-to-predict tokens and improve the LM's ability to directly answer difficult questions. In particular, after continued pretraining of an LM on a corpus of internet text with Quiet-STaR, we find zero-shot improvements on GSM8K (5.9%→10.9%) and CommonsenseQA (36.3%→47.2%) and observe a perplexity improvement of difficult tokens in natural text. Crucially, these improvements require no fine-tuning on these tasks. Quiet-STaR marks a step towards LMs that can learn to reason in a more general and scalable way.
DSPy is a framework for algorithmically optimizing LM prompts and weights, especially when LMs are used one or more times within a pipeline. To use LMs to build a complex system without DSPy, you generally have to: (1) break the problem down into steps, (2) prompt your LM well until each step works well in isolation, (3) tweak the steps to work well together, (4) generate synthetic examples to tune each step, and (5) use these examples to finetune smaller LMs to cut costs. Currently, this is hard and messy: every time you change your pipeline, your LM, or your data, all prompts (or finetuning steps) may need to change.
To make this more systematic and much more powerful, DSPy does two things. First, it separates the flow of your program (modules) from the parameters (LM prompts and weights) of each step. Second, DSPy introduces new optimizers, which are LM-driven algorithms that can tune the prompts and/or the weights of your LM calls, given a metric you want to maximize.
DSPy can routinely teach powerful models like GPT-3.5 or GPT-4 and local models like T5-base or Llama2-13b to be much more reliable at tasks, i.e. having higher quality and/or avoiding specific failure patterns. DSPy optimizers will "compile" the same program into different instructions, few-shot prompts, and/or weight updates (finetunes) for each LM. This is a new paradigm in which LMs and their prompts fade into the background as optimizable pieces of a larger system that can learn from data. tldr; less prompting, higher scores, and a more systematic approach to solving hard tasks with LMs.
You can run this tool on the entire directory and it would generate a well-formatted Markdown prompt detailing the source tree structure, and all the code. You can then upload this document to either GPT or Claude models with higher context windows and ask it to:
Rewrite the code to another language. Find bugs/security vulnerabilities. Document the code. Implement new features. You can customize the prompt template to achieve any of the desired use cases. It essentially traverses a codebase and creates a prompt with all source files combined. In short, it automates copy-pasting multiple source files into your prompt and formatting them along with letting you know how many tokens your code consumes.
With DSPy -- you can build your system using predefined modules, replacing intricate prompting techniques with straightforward, effective solutions. (Khattab et al. 2023)
Whether you're working with powerhouse models like GPT-3.5 or GPT-4, or local models such as T5-base or Llama2-13b, DSPy seamlessly integrates and enhances their performance in your system.
Khattab tweet on Meijer leaving Meta [via](https://x.com/lateinteraction/status/1772758620511310112) See also: [Virtual Machinations: Leveraging the Linguistic Bytecode of Large Language Models to Emulate Programming Language VMs](https://myconf.io/news/myconf-2024/speaker-announcement-erik-meijer/)
DSPy's biggest strength is also the reason it can admittedly be hard to wrap your head around it.
It's basically say: LLMs & their methods will continue to improve but not equally in every axis, so:
What's the smallest set of fundamental abstractions that allow you to build downstream AI software that is "future-proof" and rides the tide of progress?
Equivalently, what are the right algorithmic problems that researchers should focus on to enable as much progress as possible for AI software?
But this is necessarily complex, in the sense that the answer has to be composed of a few things, not one concept only. (Though if you had to understand one concept only, the fundamental glue is DSPy Signatures.)
It's actually only a handful of bets, though, not too many. I've been tweeting them non-stop since late 2022, but I've never collected them in one place.
All of these have proven beyond a doubt to have been the right bets so far for 2.5 years, and I think they'll stay the right bets for the next 3 years at least.
Information Flow is the single most key aspect of good AI software.
As foundation models improve, the bottleneck becomes basically whether you can actually (1) ask them the right question and (2) provide them with all the necessary context to address it.
Since 2022, DSPy addressed this in two directions: (i) free-form control flow ("Compound AI Systems" / LM programs) and (ii) Signatures.
Prompts have been a massive distraction here, with people thinking they need to find the magical keyword to talk to LLMs. From 2022, DSPy put the focus on Signatures (back then called Templates) which force you to break down LM interactions into structured and named input fields and structured and named output fields.
Getting simply those fields right was (and has been) a lot more important than "engineering" the "right prompt". That's the point of Signatures. (We know it's hard for people to force them to define their signatures so carefully, but if you can't do that, your system is going to be bad.)
Interactions with LLMs should be Functional and Structured. Again, prompts are bad. People are misled from their chat interaction with LLMs to think that LLMs should take "strings", hence the magical status of "prompts". But actually, you should define a functional contract. What are the things you will give to the function? What is the function supposed to do with them? What is it then supposed to give you back? This is again Signatures. It's (i) structured inputs, (ii) structured outputs, and (iii) instructions. You've got to decouple these three things, which until DSP (2022) and really until very recently with mainstream structured outputs, were just meshed together into "prompts". This bears repeating: your programmatic LLM interactions need to be functions, not strings. Why? Because there are many concerns that are actually not part of the LLM behavior that you'd otherwise need to handle ad-hoc when working with strings: - How do you format the inputs to your LLM into a string? - How do you separate instructions and inputs (data)? - How do you specify the output format (string) that your LLM should produce so you can parse it? - How do you layer on top of this the inference strategy, like CoT or ReAct, without entirely rewriting your prompt? Signatures solve this. They ask you to just specify the input fields, output fields, and task instruction. The rest are the job of Modules and Optimizers, which instantiate Signatures. 3) Inference Strategies should be Polymorphic Modules. This sounds scary but the point is that all the cool general-purpose prompting techniques or inference-scaling strategies should be Modules, like the layers in DNN frameworks like PyTorch. Modules are generic functions, which in this case take any Signature, and instantiate its behavior generically into a well-defined strategy. This means that we can talk about "CoT" or "ReAct" without actually committing at all to the specific task (Signature) you want to apply them to. This is a huge deal, which again only exists in DSPy. One key thing that Modules do is that they define parameters. What part(s) of the Module are fixed and which parts can be learned? For example, in CoT, the specific string that asks the model to think step by step could be learned. Or the few-shot examples of thinking step by step should be learnable. In ReAct, demonstrations of good trajectories should be learnable. 4) Specification of your AI software behavior should be decoupled from learning paradigms. Before DSPy, every time a new ML paradigm came by, we re-wrote our AI software. Oh, we moved from LSTMs to Transformers? Or we moved from fine-tuning BERT to ICL with GPT-3? Entirely new system. DSPy says: if you write signatures and instantiate Modules, the Modules actually know exactly what about them can be optimized: the LM underneath, the instructions in the prompt, the demonstrations, etc. The learning paradigms (RL, prompt optimization, program transformations that respect the signature) should be layered on top, with the same frontend / language for expressing the programmatic behavior. This means that the same programs you wrote in 2023 in DSPy can now be optimized with dspy.GRPO, the way they could be optimized with dspy.MIPROv2, the way they were optimized with dspy.BootstrapFS before that. The second half of this piece is Downstream Alignment or compile-time scaling. Basically, no matter how good LLMs get, they might not perfectly align with your downstream task, especially when your information flow requires multiple modules and multiple LLM interactions. You need to "compile" towards a metric "late", i.e. after the system is fully defined, no matter how RLHF'ed your models are. 5) Natural Language Optimization is a powerful paradigm of learning. We've said this for years, like with the BetterTogether optimizer paper, but you need both fine-tuning and coarse-tuning at a higher level in natural language. The analogy I use all the time is riding a bike: it's very hard to learn to ride a bike without practice (fine-tuning), but it's extremely inefficient to learn avoiding to ride the bike on the side walk from rewards, you want to understand and learn this rule in natural language to adhere ASAP. This is the source of DSPy's focus on prompt optimizers as a foundational piece here; it's often far superior in sample efficiency to doing policy gradient RL if your problem has the right information flow structure. That's it. That's the set of core bets DSPy has made since 2022/2023 until today. Compiling Declarative AI Functions into LM Calls, with Signatures, Modules, and Optimizers.
Information Flow is the single most key aspect of good AI software.
Interactions with LLMs should be Functional and Structured.
Inference Strategies should be Polymorphic Modules.
Specification of your AI software behavior should be decoupled from learning paradigms.
Natural Language Optimization is a powerful paradigm of learning.
I used to think that frameworks that make prompt engineering easier, are the way to go. But then I just began converting some existing prompts into DSPy signatures, and soon realized that modules in DSPy are infinitely composable. You can build almost anything with signatures and modules. There are quite a lot of misconceptions out there about DSPy: that it's mainly about prompt optimization, that you need tons of training data. What it's really about instead, is just finding that better abstraction to translate human intent to LMs. The more time you spend with DSPy, the more you realize that PROMPTS AREN'T A GOOD ABSTRACTION. Signatures and modules are a far better interface, and it so happens that there's this thing called optimizers that can help discover better prompts. But it all starts with signatures and modules. I recommend just translating a couple of use cases from other frameworks to DSPy and seeing it for yourself. It doesn't take all that much time. -- x.com/tech_optimist
Good enough prompt, portable across models and tasks/evals, faster. This “faster” is doing the heavy lifting. When you’re faster at the prompt layer, you have much more time to iterate on what actually matters: programming (aka context engineering) via error analysis. -- X/DSPyOSS
Radicle is an open source, peer-to-peer code collaboration stack. It leverages Git’s architecture combined with cryptography and a gossip protocol to enable a fully sovereign developer stack.
Introducing Devin, the first AI software engineer And setting a new state of the art on the SWE-bench coding benchmark
Meet Devin, the world’s first fully autonomous AI software engineer. Devin is a tireless, skilled teammate, equally ready to build alongside you or independently complete tasks for you to review.
With Devin, engineers can focus on more interesting problems and engineering teams can strive for more ambitious goals.
mprocs runs multiple commands in parallel and shows output of each command separately.
When you work on a project you very often need the same list of commands to be running. For example: webpack serve, jest --watch, node src/server.js. With mprocs you can list these command in mprocs.yaml and run all of them by running mprocs. Then you can switch between outputs of running commands and interact with them.
It is similar to concurrently1 but mprocs shows output of each command separately and allows to interact with processes (you can even work in vim inside mprocs).
Build AI agents that actually work 🚀 Support customers. Answer internal questions. Automate business tasks. Create your own LLM bot powered by ChatGPT.
