dspy

framework that tackles the problem of agent graph optimization although research on this topic has been done [2][3][4] [1]DSPy: The framework for programming—not prompting—foundation models: https://github.com/stanfordnlp/dspy [2]TextGrad: Automatic 'Differentiation' via Text -- using large language models to backpropagate textual gradients: https://github.com/zou-group/textgrad [3]What's the Magic Word? A Control Theory of LLM Prompting: https://arxiv.org/abs/2310.04444 [4]Language Agents as Optimizable Graphs: https://arxiv.org/abs/2402.16823

ultra parameter efficient techniques, while Dspy will likely fade into obscurity over time. I also know that the folks writing better samplers/optimizers for LLMs get almost no love/credit relative to the outsized impact they have on the field. A new sampler potentially improves EVERY LLM EVER! Folks like Clara Meister or the authors of the min_p paper preprint have had far larger impacts on the field than their citation counts might suggest, based on the fact that typiciality or min_p sampling is now considered generally superior to top_p/top_k (OpenAI, Anthropic, Gemini, et al still use top_p/top_k) and min_p/typicality are implemented by every open source LLM inference engine (i.e. huggingface, vllm, sglang, etc)

ain you are back to square one. This is a monolithic and unsustainable way to optimize. This is what DSPy tries to solve. DSPy is primarily two things: 1. Separate programming from prompt engineering using signatures and give greater control to program language models using traditional programming techniques. 2. Incorporate best practice prompting techniques in the framework to optimize the LMs response. With DSPy, you can implement and iterate on improving your app additional tools at your disposal. First, you can separate your prompts and write a signature instead. A signature looks like this “context, question -> answer”. This signature gets “compiled” into an actual prompt. In addition, you can also break this problem into 2 modules, 1. Retrieval module 2. Generation module Modules are classes that that take a signature with inputs and generate an output and you can start iterating on each module separately. Now, with the retrieval module, you can do a an iterative query generation & context retrieval before passing it to the generation module. This is a technique used to improve RAG performance by building up additional context by incrementally asking questions based on retrieved context and using the generate questions to retrieve additional context. With DSPy, this becomes straightforward because, DSPy exposes constructs like - Settings where you can define the number of hops - Signature like “context, question -> query” that gets compiled into a proper prompt - Optimizers to incrementally append retrieved contexts to the prompt automatically by the framework Coming to the answer generation module, it’s not atypical to define a set of rules while prompt engineering. DSPy solves this using run time assertions with backtracking where in, you can define an assertion instead of a rule and DSPy with automatically backtrack and improve the prompt if the assertion fails. DSPy will automatically back track and prefix the prompt to include additional rules to optimize the prompt further. Obviously, you can do this with prompt engineering & program composition. But, where DSPy really shines is when you are optimizing a large pipeline that is prone to brittleness with prompt engineering techniques. DSPy helps you compose the pipeline into isolated set of modules & lets you apply best practice prompting techniques without having to think much about the prompt. There are two implementations of the framework today. - Python - https://github.com/stanfordnlp/dspy - Typescript - https://github.com/dosco/llm-client/ One specific feature I would like to see is to expose the prompt templates as config and give greater control to the developers in incorporating our “versions” of templates for CoT, Fewshots etc. This will also help with the adoption of DSPy to languages other than English. Finally, I was able to understand what DSPy is adding to its prompts and what sort of optimizations it is doing by using Langtrace, an open source tracing tool i am building that can be setup with just 2 lines of code. https://github.com/Scale3-Labs/langtrace

etween Pydantic - which is *just about* the data layer itself - and an observability tool seems very interesting to me, and having this come from the folks who built it does not seem unreasonable. WRT open source and monetization, I would be lying if I said I wasn’t a little worried - given the recent few months - but I am choosing to see this in a positive light, given this team’s “believability weight” (to overuse Dalio) and history of delivering solid and really useful tooling.

ttps://github.com/skypilot-org/skypilot [5] https://github.com/modal-labs/llm-finetuning