new blog

bifrost/app/blog/blogs/ai-best-practices/src.mdx

@@ -32,18 +32,21 @@ In the following section, we will go over the best practices when building with
 
 ## Best Practices
 
-### 1. Define Key Performance Metrics
+## 1. Define Key Performance Metrics
 
 To effectively monitor the performance of your AI app, it's crucial to define key performance metrics (KPIs) that align with your goals.
 
-You can use observability tools to track and visualize these essential metrics such as latency, usage and costs, to make sure the models you use in your AI application run optimally. Here are some key metrics to focus on:
+### Key Metrics
 
 - **Latency**: Measure the time taken for the model to generate a response.
 - **Throughput**: Track the number of requests handled by the model per second.
 - **Accuracy**: Evaluate the correctness of the model's predictions.
 - **Error Rate**: Track the frequency of errors or failures in model predictions.
 
-**<span style={{color: '#0ea5e9'}}>Video: Helicone's pre-built dashboard metrics and the ability to segment data.</span>**
+
+### Segmentating Data on Helicone's Dashboard
+
+**Tip:** Look for a solution that provides a real-time dashboard to monitor key metrics and is **<span style={{color: '#0ea5e9'}}>capable of handling large data volumes</span>**.
 
 <video width="100%" controls autoplay loop>
   <source
@@ -53,20 +56,29 @@ You can use observability tools to track and visualize these essential metrics s
   Your browser does not support the video tag.
 </video>
 
-**<span style={{color: '#0ea5e9'}}>Tip:</span>** Make sure to look for a solution that provides a real-time dashboard to monitor key metrics and is capable of handling large data volumes.
+**<span style={{color: '#0ea5e9'}}>How Helicone can help you:</span>**
+
+Use Helicone to track and visualize essential metrics such as latency, costs and Time To First Tokens (TTFT) on the Dashboard. By continuing to monitor key application performance metrics, you can make improvemnets to your AI application easily. 
+
+**<span style={{color: '#0ea5e9'}}>You might find this useful:</span>**
+
+- [5 Powerful Techniques to Reduce LLM Costs by Up to 90%](https://www.helicone.ai/blog/slash-llm-cost)
 
 ---
 
-### 2. Implement Comprehensive Logging
+## 2. Implement Comprehensive Logging
 
-Logging is a fundamental aspect of observability. It’s beneficial to implement detailed logging to capture critical events and data points throughout your app’s lifecycle. Key logging practices include:
+Logging is a fundamental aspect of observability. It’s beneficial to implement detailed logging to capture critical events and data points throughout your app’s lifecycle. 
+
+### What to Log
 
 - **Request and response**: Record the inputs and outputs of each request to track the model’s behavior over time.
 - **Errors**: Capture errors and exceptions for troubleshooting and debugging.
 - **Performance**: Log latency, errors, usage and costs to identify performance bottlenecks.
 - **User feedback**: For models interacting with users, log your user’s inputs and feedback to discover opportunities to improve your app’s performance in real-world scenarios.
 
-**<span style={{color: '#0ea5e9'}}>Video: Adding custom properties in Helicone for advanced segmentation of requests.</span>**
+
+### Adding Custom Properties for Advanced Segmentation
 
 <video width="100%" controls autoplay loop>
   <source src="/static/blog/ai-best-practices/2. Implement Comprehensive Logging.mp4" />
@@ -77,9 +89,13 @@ Logging is a fundamental aspect of observability. It’s beneficial to implement
 
 Helicone provides advanced filtering and search capabilities, allowing you to quickly pinpoint and resolve issues. The platform also supports customizable properties you can attach to your requests to meet your specific needs.
 
+**<span style={{color: '#0ea5e9'}}>You might find this useful:</span>**
+
+- [How to Use Custom Properties to Understand Your Users Better](https://www.helicone.ai/blog/custom-properties)
+
 ---
 
-### 3. **Monitor Prompt Outputs**
+## 3. Monitor Prompt Outputs
 
 As an AI app developer, it's vital to monitor the output every time you change a prompt. This requires a tool to validate that the new prompts not only perform better but also remain compatible with previous request inputs made by your users.
 
@@ -90,7 +106,7 @@ Without a proper monitoring tool to facilitate the regression testing so develop
 - **Applicable with previous inputs**: Your app likely has a history of user interactions and inputs. It's important that new prompts continue to work well with these historical inputs.
 - **Regular testing**: Make sure changes improve performance without unintended consequences by setting up alerts.
 
-**<span style={{color: '#0ea5e9'}}>Video: Experimenting with a new prompt on an existing set of data and comparing the output.</span>**
+### Create Experiments and Compare LLM Outputs
 
 <video width="100%" controls autoplay loop>
   <source src="/static/blog/ai-best-practices/3. Monitor Prompt Outputs .mp4" />
@@ -101,9 +117,13 @@ Without a proper monitoring tool to facilitate the regression testing so develop
 
 Helicone has a dedicated playground for prompt testing and experimentation without affecting production data. In the playground, you can test different configurations of models with your new prompts and datasets to check for improvements.
 
+**<span style={{color: '#0ea5e9'}}>You might find this useful:</span>**
+
+- [What to Look for in a Prompt Management Tool](https://www.helicone.ai/blog/prompt-management)
+
 ---
 
-### 4. **Implement Safety and Security Measures**
+## 4. Implement Safety and Security Measures
 
 Generative AI is quickly changing the cybersecurity landscape. When building LLMs, it’s crucial to protect against **<span style={{color: '#0ea5e9'}}>harmful user requests</span>** and **<span style={{color: '#0ea5e9'}}>prompt attacks</span>** that could bypass the safety guardrails of your models. It's essential to understand the risks and safety issues involved with LLMs.
 
@@ -128,12 +148,18 @@ Helicone provides <a href="https://docs.helicone.ai/features/advanced-usage/mode
 
 ---
 
-### Conclusion
+## Conclusion
 
 Keeping your AI app reliable hinges on effective observability and performance monitoring. This means defining important performance metrics, setting up thorough logging, monitoring your outputs regularly, and ensuring safety and security measures are in place. By following these best practices, you can boost the performance and reliability of your LLM deployments and accelerate your AI development.
 
+
+---
+
+## Not sure where to start? 
+- 
+
 ---
 
-### Try Helicone for free.
+## Try Helicone for free.
 
     <a href="https://www.helicone.ai/" target="_blank" rel="noopener noreferrer">Sign up</a> or <a href="https://www.helicone.ai/contact" target="_blank" rel="noopener noreferrer">contact us</a>.

bifrost/app/blog/blogs/key-lessons-build-ai-agents/metadata.json

@@ -0,0 +1,10 @@
+{
+  "title": "Key Lessons Learned from Building AI Agents",
+  "title1": "Key Lessons Learned from Building AI Agents",
+  "title2": "Key Lessons Learned from Building AI Agents",
+  "description": "Making AI agents think better is more crucial than just feeding them more data. Patrick highlights that the real competitive edge isn't just in the agents themselves but in the infrastructure supporting them. ",
+  "images": "/static/blog/ai-agent-key-lessons-cover.webp",
+  "time": "4 minute read",
+  "author": "Lina Lam",
+  "date": "September 17, 2024"
+}

bifrost/app/blog/blogs/key-lessons-build-ai-agents/src.mdx

@@ -0,0 +1,65 @@
+Making AI agents think better is more crucial than just feeding them more data. Patrick highlights that the real competitive edge isn't just in the agents themselves but in the infrastructure supporting them. 
+
+![Key Lessons from Building AI Agents](/static/blog/ai-agent-key-lessons-cover.webp)
+
+## The TL;DR
+
+In "Building AI Agents: Lessons Learned over the past Year," **Patrick Dougherty** shares his hands-on experience from a year of developing AI agents. He emphasizes that making AI agents think better is more crucial than just feeding them more data. **<span style={{color: '#0ea5e9'}}>Patrick highlights that the real competitive edge isn't just in the agents themselves but in the infrastructure supporting them</span>**.
+
+## Key Insights for Building Effective AI Agents
+
+1. Reasoning over memorization: enhancing ai agent thought processes
+2. The critical role of the agent-computer interface (ACI)
+3. Navigating the limitations of current AI models
+4. Why fine-tuning may hinder your AI agent
+5. Steer clear of over-abstraction with third-party libraries
+6. Infrastructure is your competitive advantage, not the agent
+7. Preparing for future advances in AI models
+
+## About the Author
+
+**Patrick Dougherty** is an AI practitioner who has spent the past year in building and refining AI agents. Collaborating with engineers and UX designers, he’s focused on creating platforms that allow businesses to use standard data analysis agents and develop custom ones tailored to specific tasks. With hands-on experience integrating AI agents into Fortune 500 companies, Patrick brings practical insights into deploying AI in real-world scenarios.
+
+## What We've Learned
+**<span style={{color: '#0ea5e9'}}>Reasoning is more important than knowledge</span>**
+- *Thinking Over Recalling*: Agents should be designed to reason through problems, not just recall information.
+- *Handle Failures Gracefully*: Design agents to learn from errors (e.g., SQL query failures) and iteratively improve outcomes.
+
+**<span style={{color: '#0ea5e9'}}>The best way to improve performance is by iterating on the Agent-Computer Interface (ACI)</span>**
+- *Continuous Refinement*: Regularly adjust the syntax and structure of tool calls to enhance agent understanding.
+- *Model-Specific Adjustments*: Tailor the ACI to suit the strengths and weaknesses of different AI models.
+
+**<span style={{color: '#0ea5e9'}}>Agents are limited by their models</span>**
+- *Model Choice Matters*: The underlying AI model significantly affects agent performance and decision-making capabilities.
+- *Comparative Performance*: Higher-end models like GPT-4 outperform others in planning and executing complex tasks.
+
+**<span style={{color: '#0ea5e9'}}>Fine-tuning models to improve agent performance is a waste of time</span>**
+- *Avoid Over-Reliance on Examples*: Fine-tuned models may struggle with reasoning through new, unseen problems.
+- *Selective Use of Fine-Tuning*: It may be beneficial for specific tasks but not for overall agent reasoning.
+
+**<span style={{color: '#0ea5e9'}}>If you're building a product, avoid using abstractions like LangChain and LlamaIndex</span>**
+- *Maintain Direct Control*: Owning each model interaction aids in debugging and scalability.
+- *Understand Inputs and Outputs*: Direct management leads to more robust and adaptable agents.
+
+**<span style={{color: '#0ea5e9'}}>Your agent is not your moat</span>**
+- *Focus on Infrastructure*: Competitive advantage lies in security, data connectors, user interface, long-term memory, and evaluation frameworks.
+- *Critical Components*:
+    - **Security**: Protect user data and control access.
+    - **Data Connectors**: Ensure seamless integration with various databases and APIs.
+    - **User Interface**: Create transparent and interactive experiences for users.
+    - **Long-Term Memory**: Implement mechanisms for the agent to retain and recall past information.
+    - **Evaluation**: Develop frameworks to assess and improve agent performance.
+
+**<span style={{color: '#0ea5e9'}}>Don’t bet against models continuing to improve</span>**
+- *Design for Adaptability*: Build agents that can easily integrate advancements in AI models.
+- *Avoid Over-Customization*: Overfitting to current models may hinder future compatibility and performance.
+
+**<span style={{color: '#0ea5e9'}}>Additional lessons learned</span>**
+- *Open-Source Models May Lag Behind*: Currently, they might not match proprietary models in reasoning abilities.
+- *Premature Optimization Can Backfire*: Focus on functionality before cost-cutting.
+- *Enhance User Experience*: Implement features like token streaming to improve perceived performance.
+- *Embrace Iterative Development*: Continuously learn and adapt to improve AI agents.
+
+## What are your thoughts?
+
+Anything else you’d like to add? Please <a href="https://github.com/Helicone/helicone/pulls" target="_blank" rel="noopener noreferrer">raise an issue</a> and we’d love to share your tips!

bifrost/app/blog/page.tsx

@@ -190,6 +190,11 @@ export type BlogStructure =
     };
 
 const blogContent: BlogStructure[] = [
+  {
+    dynmaicEntry: {
+      folderName: "key-lessons-build-ai-agents",
+    },
+  },
   {
     dynmaicEntry: {
       folderName: "prompt-engineering-tools",