diff --git a/bifrost/app/blog/blogs/ai-best-practices/src.mdx b/bifrost/app/blog/blogs/ai-best-practices/src.mdx
index af5d14bc72..5cc74068ea 100644
--- a/bifrost/app/blog/blogs/ai-best-practices/src.mdx
+++ b/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.
-**Video: Helicone's pre-built dashboard metrics and the ability to segment data. **
+
+### Segmentating Data on Helicone's Dashboard
+
+**Tip:** Look for a solution that provides a real-time dashboard to monitor key metrics and is **capable of handling large data volumes **.
-**Tip: ** 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.
+**How Helicone can help you: **
+
+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.
+
+**You might find this useful: **
+
+- [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.
-**Video: Adding custom properties in Helicone for advanced segmentation of requests. **
+
+### Adding Custom Properties for Advanced Segmentation
You might find this useful: **
+
+- [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.
-**Video: Experimenting with a new prompt on an existing set of data and comparing the output. **
+### Create Experiments and Compare LLM Outputs
You might find this useful: **
+
+- [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 **harmful user requests ** and **prompt attacks ** 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 Sign up or contact us .
diff --git a/bifrost/app/blog/blogs/key-lessons-build-ai-agents/metadata.json b/bifrost/app/blog/blogs/key-lessons-build-ai-agents/metadata.json
new file mode 100644
index 0000000000..cf90450856
--- /dev/null
+++ b/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"
+}
diff --git a/bifrost/app/blog/blogs/key-lessons-build-ai-agents/src.mdx b/bifrost/app/blog/blogs/key-lessons-build-ai-agents/src.mdx
new file mode 100644
index 0000000000..12a1dc0a47
--- /dev/null
+++ b/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.
+
+
+
+## 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. **Patrick highlights that the real competitive edge isn't just in the agents themselves but in the infrastructure supporting them **.
+
+## 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
+**Reasoning is more important than knowledge **
+- *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.
+
+**The best way to improve performance is by iterating on the Agent-Computer Interface (ACI) **
+- *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.
+
+**Agents are limited by their models **
+- *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.
+
+**Fine-tuning models to improve agent performance is a waste of time **
+- *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.
+
+**If you're building a product, avoid using abstractions like LangChain and LlamaIndex **
+- *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.
+
+**Your agent is not your moat **
+- *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.
+
+**Don’t bet against models continuing to improve **
+- *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.
+
+**Additional lessons learned **
+- *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 raise an issue and we’d love to share your tips!
\ No newline at end of file
diff --git a/bifrost/app/blog/page.tsx b/bifrost/app/blog/page.tsx
index b916492104..709bc0f454 100644
--- a/bifrost/app/blog/page.tsx
+++ b/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",
diff --git a/bifrost/public/static/blog/ai-agent-key-lessons-cover.webp b/bifrost/public/static/blog/ai-agent-key-lessons-cover.webp
new file mode 100644
index 0000000000..c29cdf1d3d
Binary files /dev/null and b/bifrost/public/static/blog/ai-agent-key-lessons-cover.webp differ