Forem: Gabriel Vanderlei

Exploring My OpenAI Agents Examples Repository

Gabriel Vanderlei — Sat, 22 Mar 2025 17:34:08 +0000

As the creator of the openai-agent-examples repository, I wanted to share some practical implementations for using the OpenAI Agents library. In this post, I'll walk you through what's available in my repository and how you can use it to create your own AI agents.

How I Structured the Repository

I divided the repository into two distinct sets of code:

Introductory Examples (1-5): These are identical to the examples in the official documentation, allowing you to test basic functionalities in a controlled environment. I included these to provide a clear starting point and ensure you can see the foundational concepts working before diving into more complex implementations.
Practical Projects (6-8): Three more sophisticated projects that explore additional possibilities in scenarios closer to real-world applications. These build on the basic concepts but demonstrate how to create fully functional systems.

What is OpenAI Agents?

When I started working with OpenAI Agents, I conceptualized it as a system that operates much like a web framework:

Triage: Acts as a router that directs requests
Handoffs: Represents the available routes
Guardrails: Defines the format and validation of requests
Agents: Process specific requests based on their specializations

My Repository Structure

I've organized the repository into several key sections:

openai-agent-examples/
├── 1-5_introduction_examples/  # Basic examples from documentation
├── 6_simple_chat/              # First practical implementation
├── 7_simple_chat_with_apis/    # Advanced implementation with API integration
├── 8_simple_chat_with_gradio/  # UI-focused implementation
├── .env.example
├── .gitignore
└── README.md

Introductory Examples (1-5)

These examples mirror what you'll find in the official documentation, providing a solid foundation:

1. Simple Agent (`simple_agent.py`)

Creating a basic agent with defined instructions:

from agents import Agent

agent = Agent(
    name="Math Tutor",
    instructions="You provide help with math problems. Explain your reasoning at each step and include examples",
)

2. Handoffs Between Specialized Agents

A triage system that routes questions to specialized agents:

triage_agent = Agent(
    name="Triage Agent",
    instructions="You determine which agent to use based on the user's homework question",
    handoffs=[history_tutor_agent, math_tutor_agent]
)

3. Input Guardrails

Safety checks using Pydantic models:

from agents import Agent, InputGuardrail, GuardrailFunctionOutput, Runner
from pydantic import BaseModel
import asyncio

class HomeworkOutput(BaseModel):
    is_homework: bool
    reasoning: str

4. Python Functions as Tools

Transforming Python functions into tools for agents:

@function_tool  
async def fetch_weather(location: Location) -> str:
    """Fetch the weather for a given location."""
    # In real implementations, this would call a weather API
    return "sunny"

5. Agents as Tools

Using agents as tools for orchestration:

orchestrator_agent = Agent(
    name="orchestrator_agent",
    instructions=(
        "You are a translation agent. You use the tools given to you to translate."
        "If asked for multiple translations, you call the relevant tools."
    ),
    tools=[
        spanish_agent.as_tool(
            tool_name="translate_to_spanish",
            tool_description="Translate the user's message to Spanish",
        ),
        french_agent.as_tool(
            tool_name="translate_to_french",
            tool_description="Translate the user's message to French",
        ),
    ],
)

Practical Implementations (6-8)

After exploring the basic concepts, I created three more practical implementations that go beyond the documentation examples:

6. Simple Chat

My first practical implementation is a basic chat system with conversation history support. This bridges the gap between the introductory examples and more complex systems.

7. Chat with APIs

This implementation expands to a complete asynchronous chat solution that incorporates:

Chat context management
Multiple specialized agents:
- Bitcoin Agent: Fetches real-time prices using CoinGecko's API
- Jokes Agent: Returns random or topic-related jokes
- Weather Agent: Provides weather updates for specified cities
- Time Agent: Returns the current time
- News Agent: Simulates news headline searches

This example demonstrates how to build a system that can interact with external APIs while maintaining conversation context.

8. Chat with Gradio Interface

My most advanced implementation includes a modern web interface using Gradio that adds:

Dynamic API tool registration during runtime
User-friendly UI for easier interaction
Flexible context handling across sessions
Integration with custom tools that can be added on-the-fly

This example shows how to create a deployment-ready system that end users can interact with through a web interface.

Why I Built This Repository

When I started working with OpenAI Agents, I realized there weren't many comprehensive examples showing how to build a complete system. I wanted to create a resource that would:

Demonstrate the full potential of the library beyond basic usage
Show how to integrate multiple agents in a cohesive system
Provide practical examples that address real-world challenges
Help developers understand how to maintain context in multi-turn conversations
Showcase different deployment options from command line to web interfaces

The introductory examples help you understand the basics, while the practical implementations show you how to create fully functional systems that could serve as starting points for your own projects.

Looking Forward

I'm continuing to expand this repository with more examples and use cases. If you have suggestions or would like to contribute, please feel free to open an issue or submit a pull request on GitHub.

By sharing these examples, I hope to help other developers explore the potential of the OpenAI Agents library and build their own innovative AI applications.

Happy coding!

Bolt.new with any LLM, you need to use it

Gabriel Vanderlei — Fri, 13 Dec 2024 14:05:40 +0000

The Situation

Developing agile and efficient projects using cutting-edge Large Language Models (LLMs) is becoming increasingly essential. Tools like Bolt.new have made this process easier by offering powerful features for rapid prototyping and brainstorming.

The Problem

While Bolt.new is incredibly useful, its cost can be prohibitive, especially when managing multiple projects. This limits accessibility, making it challenging for independent developers and small teams to fully leverage its capabilities.

The Solution

I discovered that the core of Bolt.new is open source! Here's why this is a game-changer:

You can run the tool locally and use your own API keys for models like Anthropic.
There’s an alternative repository, now called Bolt.DIY, hosted on the GitHub by Stackblitz Labs, previously known as "Bolt.new any LLM." This version enables:
- Integration with any LLM, including OpenAI, Grok, and Anthropic.
- Exporting chat data.
- Using Git repositories.
- Running local AI models with LMStudio or Ollama.

This approach not only reduces costs but also provides more flexibility and control over your development environment.

Why Should You Try It?

If you're looking for an efficient and cost-effective way to accelerate your developments and enhance your workflows with LLMs, the open-source Bolt.DIY with multi-LLM support is a powerful choice. Explore its possibilities and adapt the tool to meet your unique needs!

Useful Links:

Transform your development process with greater freedom and unlimited potential. 🚀

How I Created CriaLogoAI: Solving the Pain of Logo Creation with AI

Gabriel Vanderlei — Thu, 05 Dec 2024 19:26:47 +0000

Have you ever tried creating a logo using artificial intelligence but felt lost among tools in English or overly complex platforms? That’s exactly the situation that led me to create CriaLogoAI, a straightforward and optimized solution to make logo creation effortless.

The Problem: Inaccessible Tools

Recently, I needed to create educational content about image generation models like Flux and Flux 1.1. However, I faced a major obstacle: the available tools weren’t accessible for those seeking speed and simplicity, let alone optimized for the Brazilian audience.

These platforms required advanced technical knowledge, had confusing interfaces, and none of them focused on something as specific as logos. This wasn’t just my issue—many others shared the same frustrations.

The Solution: A Straightforward and Efficient Tool

That’s how CriaLogoAI came to life. The idea was simple: allow anyone to create a logo in just a few minutes. No complications, no barriers.

With CriaLogoAI, all you need is a prompt (a description of what you want), and in seconds, the logo is generated. Additionally, you can adjust details such as text (in quotes), styles, and colors. The model we use may have limitations with longer text, but it works incredibly well for short and direct phrases.

How CriaLogoAI Works

The architecture was designed to be robust and scalable while maintaining simplicity for the end user:

Image generation:
- We use the Flux Schnell model integrated via Replicate API.
Storage and security:
- Data is securely stored in MongoDB Atlas, with authentication through JWT.
Payments:
- For premium services, we’ve integrated Stripe.
Infrastructure and hosting:
- The frontend is hosted on Netlify;
- The backend runs on Google Cloud Run, ensuring high performance.
Additional tools:
- The code was generated with the help of Bolt.new by Stackblitz, speeding up development.
- We monitor the user experience with Google Analytics, Hotjar, and Posthog.

The Result: Simplicity Delivered

CriaLogoAI is more than just a tool; it’s a practical solution for those who need fast and professional results. Whether you’re a designer looking for inspiration or a small entrepreneur wanting to save time and money, CriaLogoAI is here to help.

Try It Now

Like the idea? Try it yourself by visiting CriaLogoAI.com. And of course, your feedback is always welcome! It helps us improve and evolve the tool.

If you’ve faced similar difficulties, share your experience in the comments. Let’s keep creating solutions that simplify daily life! 🚀

DSPy: A New Approach to Language Model Programming

Gabriel Vanderlei — Thu, 28 Nov 2024 11:59:23 +0000

The Challenge: Moving Beyond Traditional Prompting

When working with Language Models (LLMs), developers face a common set of challenges. We spend countless hours crafting perfect prompts, only to find that our carefully engineered solutions break when we switch models or when the input slightly changes. The traditional approach of prompt engineering is manual, time-consuming, and often unpredictable.

The Solution: Stanford's DSPy Framework

DSPy (Declarative Self-improving Python) emerges as Stanford NLP's answer to these challenges. As described on their website (dspy.ai), it's "the open-source framework for programming - rather than prompting - language models." It enables fast iteration on building modular AI systems and provides algorithms for optimizing prompts and weights, whether you're building simple classifiers, sophisticated RAG pipelines, or Agent loops.

How It Works: The Core Components

1. Getting Started

First, install the framework:

pip install -U dspy

import dspy
lm = dspy.LM('openai/gpt-4-mini', api_key='YOUR_OPENAI_API_KEY')
dspy.configure(lm=lm)

2. Understanding Signatures

Signatures are the foundation of DSPy's declarative approach. They define the semantic roles for inputs and outputs in a simple format:

# Simple question answering
"question -> answer"

# Retrieval-based QA
"context: list[str], question: str -> answer: str"

# Multiple-choice with reasoning
"question, choices: list[str] -> reasoning: str, selection: int"

3. Working with Modules

DSPy provides several key modules for different use cases:

Predict: Direct LLM responses
ChainOfThought: Step-by-step reasoning
ProgramOfThought: Code-based solutions
ReAct: Agent-based interactions
MultiChainComparison: Compare multiple reasoning paths

4. Real-World Applications

Mathematical Problem Solving

math = dspy.ChainOfThought("question -> answer: float")
math(question="Two dice are tossed. What is the probability that the sum equals two?")

Retrieval-Augmented Generation (RAG)

def search_wikipedia(query: str) -> list[str]:
    results = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')(query, k=3)
    return [x['text'] for x in results]

rag = dspy.ChainOfThought('context, question -> response')

Beyond the Basics

DSPy supports various advanced use cases:

Classification tasks
Information extraction
Agent-based systems with tools
Complex RAG pipelines

The framework's self-improving nature means your applications can optimize their performance over time, learning from interactions and results.

Ready to Start?

You can find complete examples and explore more use cases in the DSPy documentation and the community repository at https://github.com/gabrielvanderlei/DSPy-examples.

DSPy represents a paradigm shift from traditional prompt engineering to declarative programming with language models. It brings structure, reliability, and predictability to LLM development, making it easier to build and maintain AI-powered applications.