Видео

Hey Christian! Really enjoy your videos, are you on Twitter by any chance? Would love to share some stuff with you

Did you forget to add the graphQl frontend code to Github ?

your channel is really really good. Can you share what tool you use to create the web UI?

You're an excellent teach Christian, thank you for this video!

Hey I'm building a health tech app rn and your videos are so helpful. Thank you !

“I won’t go through how I actually built the application” what’s the point ? I switched off here.

I like your videos! Keep on doing more videos 😊

Superb content, Thanks for sharing ✨

🎯 Key Takeaways for quick navigation: 00:00 *🧩 Swapping Between Local and Serverless Models* - Easily switch between local LLMs and serverless models using the OpenAI API. - Challenges and considerations when using serverless options like AMA for open AI compatibility. - Demonstrating how to toggle and set up models for different requests effortlessly. 03:37 *🚀 Utilizing Various Models in Tool Calling* - Exploring the models compatible with tool calling in serverless options like Together. - Highlighting the importance of model support for tool calling functionalities. - Demonstrating how to effectively run requests through different models and analyze their responses. 08:25 *💻 Optimizing the Model Selection Process* - Comparing the efficiency of different models for tool calling, including MRA, M, and Mistral. - Discussing the flexibility of interchanging models based on performance and cost factors. - Sharing insights on the future landscape of model swapping and the competitive advantages of serverless models. Made with HARPA AI

🎯 Key Takeaways for quick navigation: 00:00 *🤖 Agent Prototype Overview* - Developing a sophisticated agentic workflow involving multiple steps. - Streaming data back in bits instead of waiting for completion. - Exploring agent workflows in co-pilot experiences with Llama 3 and Groq for fast inference. 02:04 *🚀 Building AI Tools for Product Teams* - Creating an AI tool for rapid brainstorming and product vision establishment. - Extracting core ideas such as business objectives, customer problems, and enabling technologies. - Using a step-by-step approach with vision writing agents to refine the product vision. 05:48 *⚡️ Fast Inference with Llama 3 and Groq* - Leveraging Groq's super-fast inference engine for agent workflows. - The speed advantage of Groq's 300 tokens per second compared to other models. - The future trend towards faster and cheaper inference models like Llama 3 challenging traditional models. Made with HARPA AI

🎯 Key Takeaways for quick navigation: 00:01 *🛠️ Building a self-improving prompt engineering agent* - Explained the concept of developing an agent capable of running evaluations, revising prompts, and learning from its own evaluations iteratively. - Shared the process of setting up evaluations, scoring runs, and building the agent to handle prompt iteration. - Emphasized the need for thorough evaluations to ensure confidence in shipping the prompt. 08:12 *🔄 Utilizing AI for prompt generation and evaluation loops* - Described a loop mechanism involving an agent and tools for prompt revision and evaluation. - Discussed the importance of using specific models for prompt development, evaluation, and validation. - Introduced the concept of passing learnings from evaluations back to the agent for continuous improvement. 13:54 *🤖 Automated prompt engineering process overview* - Provided an overview of generating synthetic data for evaluations and validating prompt performance. - Demonstrated the loop where the agent iteratively revises prompts, runs evaluations, and updates based on learnings. - Highlighted the significance of leveraging different AI models for specific stages within the prompt engineering process. 20:12 *🔄 Iterative prompt generation and testing process* - Described the iterative loop process involving running evaluations, revising prompts, and testing new versions. - Explained the role of the prompt writer in generating updated prompts based on evaluation results. - Highlighted the importance of using smart models for prompt writing to improve accuracy over time. 22:04 *🧰 Tools and datasets for prompt generation and evaluation* - Shared details on the code structure, including agents, data graphs, and tools for prompt generation. - Demonstrated the process of generating synthetic data for evaluations and fine-tuning models. - Discussed the flexibility to choose between different prompt writing tools and methodologies for evaluation. 30:02 *🧠 Final optimization steps and considerations for prompt engineering* - Discussed potential risks of over-optimization and the need to counteract them in prompt engineering. - Emphasized the significance of reserving a fresh, untouched dataset for final confirmation testing. - Encouraged experimentation while iterating on the process and seeking improvements or existing tools to enhance prompt engineering techniques. Made with HARPA AI

🎯 Key Takeaways for quick navigation: 00:00 *🧠 Building an agentic workflow from a complex prompt* - Demonstrated the process of dividing a single prompt into multiple agentic steps. - Divided the prompt into memory extraction, reflective review, action assignment, and category assignment steps. - Discussed the importance of breaking down prompts for improved accuracy and cost efficiency. 02:44 *🔄 Andrew Yang's Four Agentic Workflow Methods* - Shared insights from Andrew Yang's work on improving agentic workflows using reflection, tool use, planning, and multi-agent collaboration. - Explained how combining these methods can enhance the quality of results in workflows. - Highlighted the benefits of incorporating reflection, tool use, planning, and multi-agent collaboration in workflows. 05:17 *🚀 Enhancing Accuracy with Multi-Agent Workflows* - Demonstrated the implementation of a multi-agent workflow in processing prompts. - Showcased the division of the prompt into memory extraction, action assignment, and category assignment steps with reflective feedback loops. - Discussed the trade-offs between accuracy, cost efficiency, and processing speed in multi-agent workflows. Made with HARPA AI

🎯 Key Takeaways for quick navigation: 00:00 *🧠 Building a demo of a memory feature similar to ChatGPT's long-term memory:* - Building a cooking application to learn about personal habits and preferences. - Extracting information from conversations about allergies, food likes, and family attributes. - Demonstrating information extraction and memory feature in a conversation simulation. 03:28 *🤖 Implementing a memory management system inspired by GPT research:* - Exploring the combination of long-term and short-term memory in memory management. - Condensing messages into long-term memory after a certain threshold for optimization. - Utilizing archival and recall storage to create a comprehensive conversational memory chain. 05:18 *🔄 Setting up a memory system with separate agents for conversation management:* - Developing a conversational agent and a memory agent running in parallel. - Using Lang chain and Lang graph for memory management and reasoning. - Establishing a memory tool caller for managing memory creation, update, and deletion. 09:56 *🖥️ Implementing memory agents and memory management logic:* - Detailing the memory Sentinel's function to analyze and record relevant information. - Creating a memory manager tool for efficient memory tracking and database operations. - Demonstrating the process of memory creation, updates, and deletions using a tool caller. 14:22 *🧭 Setting up a memory graph for efficient memory and knowledge processing:* - Defining nodes and edges for memory agents, knowledge structures, and tool calling. - Illustrating the flow of information between different stages of memory processing. - Detailing the setup and execution of memory processing steps in the memory graph. 19:48 *🔍 Exploring memory optimization and customization possibilities:* - Discussing potential optimizations for storing and retrieving specific memory types. - Considering the selective retention of information based on agent requirements. - Addressing methods to tailor memory processing for different agents and use cases. 21:11 *🧠 Optimizing memory processing for efficiency and effectiveness:* - Analyzing when to condense message logs or save memories in a user session. - Exploring different strategies to optimize short-term and long-term memory retention. - Considering factors such as speed, cost, and accuracy in memory agent optimization. Made with HARPA AI

interesting UX decisions. I've also considered the idea of streaming progress from these agentic workflows for the end-user to observe the system doing its job but also just making for a more snappy experience.

Hi can you publish your langsmith traces for this? I am trying to implement this for models without tool calling. It will be incredibly helpful

A code walkthrough would be awesome!

Would really appreciate if you shared some code blocks for Langgraph and langchain

Thanks for the super cool demo. Can you provide your langsmith traces for us to inspect? it would be really easy to track the flow engineering. Thanks!

Is there a follow up video for the code walk through?

what ui are you using?

Super cool! What made you want to build it in typescript?

This langchain codes work well for one Q&A, but how to modify these to allow interactive conversations, and still able to handle the tools? Thanks!

Great content, one of the unfortunately underrated channels on youtube about LLMs real use cases. no bs, straight to action. love it. keep up the good work.

Excelent content! Thanks for sharing, man :D

my problem is that long term memory drastically increases prompt size. so you either need multiple long term memories depending on type of the prompt or local AI that server as AI router deciding what prompt needs from long term memory

what code examples did you pushed in weaviate ?

Thank you for your videos, your videos help me much more than the official LangChain videos. Could you please also a video where you use LangChain Agents e.g. the Tool Calling Agent?

Thanks for sharing! Have you experimented with asking the models to generate prompts for you for each step? It could accelerate the workflow building :)

Hi! Really good walkthrough. Have one question. How did you create and deploy the ui front end part of this? Was wondering if you used the lang serve. As a non-developer wanting to create quick proof of concept for potential users, was wondering if there's a lean way to deploy on local the user interface. Realized your github only have ipynbs. Thank you so much!

Amazing improvement on your last video on Memory. Any way I can get access to the Frontend you're using in your videos?

Thanks for this video, it's really helpful!!

Great work, don't you mind to share the code for front end? ;)

Are you open to consulting? I just emailed you

I did something similar, - generate triplets from the information - check / review triplets (if bad refine, if good go to next step) - save to neo4j as knowledge graph

Thanks for sharing this project!

Thanks for this straightforward explanation of agentic memory formation. I’m very curious about how you chose which layers should use Anthropic Claude Haiku vs OpenAI GPT-3.5-turbo.

What are you using to build the Frontend? looks neat

Grok would be fast as hell. I would be interested to see the performance looping grok in.

Thinking if there would be a way for it to build a knowledge graph... Somehow?

Can you share the vite front end? or how you setted up the front and the backend?

I liked the overview you did before jumping into the code - so helpful! Most tutorials just jump a s s backwards into the code.

🎯 Key Takeaways for quick navigation: 00:01 *🤖 Building a Self-Improving Prompt Engineer Agent* - Creating an agent capable of self-improving prompt engineering, running evaluations, revising prompts based on feedback, and learning independently. - The agent autonomously conducts prompt engineering without human intervention, relying on self-learning and iterative improvement. 02:08 *💡 Evaluation Setup and Testing* - Setting up evaluation scenarios involves creating diverse input messages, expected outputs, and testing conditions. - Synthetic data generation and validation are essential for building an accurate evaluation dataset. - Evaluations compare model outputs to expected results, determining their accuracy and guiding prompt revisions. 08:12 *🔄 Iterative Prompt Engineering Loop* - The agent continuously revises prompts based on evaluation feedback, improving its performance over successive iterations. - Prompt revisions are guided by insights from previous evaluation runs, aiming to enhance the model's effectiveness. - Leveraging feedback mechanisms and evolutionary algorithms, the agent refines prompt engineering autonomously. 17:40 *🚀 Autonomous Prompt Engineering Process* - The agent's goal is to generate effective prompts capable of handling diverse scenarios with confidence. - By cycling through evaluation iterations, the agent gains confidence in prompt engineering, leveraging extensive evaluation data. - The process culminates in the creation of prompts suitable for various conversational contexts, ensuring robust performance. 19:01 *🧩 Prompt Writing and Evaluation Process* - Describes the process of writing a new prompt and testing it against an evaluation dataset. - Components of the prompt include the user message, memories, and desired responses. - The evaluation involves comparing expected and actual outputs, iterating until a satisfactory accuracy score is achieved. 20:24 *🔄 Iterative Prompt Optimization* - Explains the iterative nature of the prompt optimization process. - Details how failures trigger revisiting the prompt writer with updated information. - Emphasizes the importance of a smart model underlying the prompt writer for better results over time. 23:49 *📊 Dataset Generation Process* - Outlines the process of generating the evaluation dataset. - Describes steps including prompt generation, memory creation, and output mutation. - Mentions the possibility of fine-tuning a model based on the dataset for comparison. 27:14 *🛠️ Graph Setup and Tools* - Discusses the setup of the Lang graph and the tools utilized within it. - Key components include the prompt writer, tester, and evaluator. - Explains the decision-making process within the graph and the tool calls for prompt writing and evaluation. 30:02 *💻 Code Overview and Considerations* - Provides an overview of the code structure and functionality. - Highlights potential areas for improvement and considerations, such as avoiding over-optimization and preserving a fresh evaluation dataset. - Encourages experimentation and feedback for further enhancements. Made with HARPA AI

Is this using DSPy

Great video!!!!

beautiful UI for evals

@deployingai amazing video, Is it possible to share the Miro link, Thank you !

Great video christiane, is it possible to share Miro link. Thanks

That was excellent

I really appreciate all of your videos. For some reason the volume on all of the content that I've seen you post is like 50% more quiet than other videos on youtube. The "why" of how these things are put together is great in your videos and I'm always glad to have a better understanding of the underlying context.

would love to hear your opinion about using dspy, you mentioned llm compiler in your parallel function video. dspy team released a paper called storm where langchain team implemented here: ruclips.net/video/1uUORSZwTz4/видео.html