DEV Community: Mazyar Yousefiniyae shad

I Built an AI Gateway That Cuts LLM Costs by 60% - Here's How

Mazyar Yousefiniyae shad — Tue, 10 Feb 2026 09:52:58 +0000

I Built an AI Gateway That Cuts LLM Costs by 60% - Here's How

If you're using OpenAI, Claude, or other LLM APIs in production, you've probably experienced two painful realities:

💸 Costs spiral out of control as usage scales
🔄 You're paying for the same requests multiple times

After seeing my company's AI bill hit $12,000/month (with 30-40% being duplicate requests), I built an open-source solution that sits between your app and LLM providers to automatically optimize costs.

🎯 The Problem

Let's say your customer service chatbot gets asked "What are your business hours?" 500 times a day. Without optimization, you're paying OpenAI for the same answer 500 times:

500 requests × $0.03 per 1K tokens = $15/day = $450/month

For just ONE common question. Multiply that across hundreds of similar queries, and you see how quickly costs explode.

💡 The Solution: An Intelligent Proxy

I built AI Cost Optimizer Proxy - a Go-based API gateway that:

✅ Caches responses using Redis (30-60% cost savings)
✅ Routes intelligently to cheaper models when appropriate
✅ Handles failures with automatic provider fallbacks
✅ Tracks everything - costs, usage, cache hit rates
✅ Works with existing code - OpenAI-compatible API

🏗️ Architecture Overview

┌─────────────┐
│ Your App    │
└──────┬──────┘
       │ (No code changes needed)
       ▼
┌─────────────────────────────────┐
│  AI Cost Optimizer Proxy        │
├─────────────────────────────────┤
│  ┌─────────┐   ┌──────────┐    │
│  │ Cache   │   │  Smart   │    │
│  │ Layer   │   │ Router   │    │
│  └─────────┘   └──────────┘    │
└────────┬────────────────────────┘
         │
    ┌────┼────┬──────┬───────┐
    ▼    ▼    ▼      ▼       ▼
  OpenAI Claude Gemini DeepSeek Grok

🚀 Key Features

1. Smart Caching

The proxy generates a SHA-256 hash from the request (model + messages + temperature) and checks Redis first:

// Pseudo-code
cacheKey := SHA256(model + messages + temperature)
if cachedResponse := redis.Get(cacheKey) {
    return cachedResponse  // Cost: $0
}

// Cache miss - call API
response := callProvider(request)
redis.Set(cacheKey, response, TTL)
return response

Real-world impact: Our customer support bot went from 10,000 API calls/day to 3,500 (65% cache hit rate).

2. Intelligent Model Routing

Not every request needs GPT-4. The proxy automatically routes based on complexity:

if tokenCount < 500 && !containsComplexKeywords(prompt) {
    model = "gpt-4o-mini"  // $0.00015 per 1K tokens
} else {
    model = "gpt-4"         // $0.03 per 1K tokens
}

Savings: 200x cost reduction on simple queries.

3. Automatic Fallback

Primary provider down? The proxy automatically tries backups:

providers := []string{"openai", "anthropic", "gemini"}
for _, provider := range providers {
    response, err := tryProvider(provider, request)
    if err == nil {
        return response
    }
}

Result: 99.9% uptime even when individual providers fail.

4. Streaming Support

Full SSE (Server-Sent Events) streaming for all providers:

curl -N -X POST http://localhost:8080/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"model":"gpt-4o-mini","stream":true,"messages":[...]}'

Real-time responses with cost tracking.

5. Cost Analytics

Built-in admin API for tracking:

GET /admin/analytics/costs

{
  "total_cost": 245.67,
  "total_requests": 45230,
  "cache_hits": 28640,
  "cache_misses": 16590,
  "estimated_saved": 156.23,
  "by_model": [
    {
      "model": "gpt-4o-mini",
      "requests": 32000,
      "cost": 4.80
    }
  ]
}

💻 Show Me The Code

Drop-In Replacement

Before:

import openai

client = openai.OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}]
)

After:

import openai

client = openai.OpenAI(
    api_key="YOUR_PROXY_KEY",
    base_url="http://localhost:8080/v1"  # Just change this!
)
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}]
)

That's it. No code changes.

📊 Real-World Results

After 30 days in production:

Metric	Before	After	Savings
Monthly Cost	$12,000	$4,800	60%
Avg Response Time	1,800ms	350ms	80% faster
API Failures	12/month	0	100%
Cache Hit Rate	0%	63%	✨

🛠️ Tech Stack

Go 1.22 - Fast, concurrent, production-ready
Gin - HTTP web framework
Redis - Cache layer
PostgreSQL - Usage tracking & analytics
Docker - Easy deployment

🚀 Getting Started

# Clone the repo
git clone https://github.com/mazyaryousefiniyaeshad/ai_cost_optimizer_proxy.git
cd ai_cost_optimizer_proxy

# Setup environment
cp .env.example .env
# Add your OpenAI/Claude/Gemini API keys

# Start infrastructure
docker-compose -f docker/docker-compose.yml up -d

# Run the proxy
go run cmd/server/main.go

Server runs on http://localhost:8080 - just point your app there!

🔐 Security Features

✅ API key authentication
✅ Rate limiting per key
✅ Admin token protection
✅ Request validation
✅ Secure key generation (crypto/rand)

📈 What's Next?

Planned features:

[ ] Request queueing for rate limit management
[ ] A/B testing between models
[ ] Custom routing rules via config
[ ] Prometheus metrics export
[ ] Web dashboard for analytics

🤝 Contributing

This is open source (MIT license)! Here's how you can help:

Add new providers - Just 30 lines of code to add Mistral, Cohere, etc.
Improve caching - Semantic similarity caching?
Build the dashboard - React/Vue frontend for analytics
Write tests - Always need more coverage

Check out the contributing guide.

🎯 Key Takeaways

Caching is your best friend - 60%+ of LLM requests are duplicates
Not all requests need GPT-4 - Smart routing saves 10-100x
Fallbacks prevent downtime - Multi-provider = reliability
Measure everything - You can't optimize what you don't track

🔗 Links

GitHub: https://github.com/mazyaryousefiniyaeshad/ai_cost_optimizer_proxy
Documentation: Full API docs in the repo
License: MIT (use it anywhere!)

💬 Discussion

Have you dealt with LLM cost explosion in your projects? What strategies worked for you? Drop a comment below!

Found this useful? ⭐ Star the repo and follow me for more production AI tools!

AI #OpenAI #Golang #DevOps #CloudCosts #MachineLearning #ChatGPT

Building Your First RAG System with Python and OpenAI

Mazyar Yousefiniyae shad — Tue, 28 Jan 2025 20:06:52 +0000

Hey there! 👋 Are you interested in building your own RAG (Retrieval Augmented Generation) system? In this post, I'll show you how to create one step by step using Python and OpenAI. RAG helps AI give better answers by first finding relevant information from your documents before generating a response. It's like giving the AI a chance to "study" before answering!

What You'll Learn
Project Setup
Folder Structure
Step 1: Setting Up the Environment
Step 2: Document Loading
Step 3: Text Processing
Step 4: Creating Embeddings
Step 5: Building the Retrieval System
Step 6: Connecting with OpenAI
Step 7: Putting It All Together
Conclusion

What You'll Learn

In this tutorial, you'll learn how to:

Set up a RAG project from scratch
Process and prepare documents for RAG
Use OpenAI embeddings
Create a simple retrieval system
Connect everything with OpenAI's API

Project Setup

First, let's look at our folder structure:

rag-project/
│
├── src/
│   ├── __init__.py
│   ├── document_loader.py
│   ├── text_processor.py
│   ├── embeddings_manager.py
│   ├── retrieval_system.py
│   └── rag_system.py
│
├── data/
│   └── documents/
│
├── requirements.txt
├── test.py
├── README.md
└── .env

Step 1: Setting Up the Environment

First, let's create our virtual environment and install the needed packages:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install openai python-dotenv numpy pandas

Create a requirements.txt file:

openai==1.12.0
python-dotenv==1.0.0
numpy==1.24.3
pandas==2.1.0

Set up your .env file:

OPENAI_API_KEY=your_api_key_here

Step 2: Document Loading

Create src/document_loader.py:

import os
from typing import List

class DocumentLoader:
    def __init__(self, documents_path: str):
        self.documents_path = documents_path

    def load_documents(self) -> List[str]:
        documents = []
        for filename in os.listdir(self.documents_path):
            if filename.endswith('.txt'):
                with open(os.path.join(self.documents_path, filename), 'r') as file:
                    documents.append(file.read())
        return documents

Step 3: Text Processing

Create src/text_processor.py:

from typing import List

class TextProcessor:
    def __init__(self, chunk_size: int = 1000):
        self.chunk_size = chunk_size

    def split_into_chunks(self, text: str) -> List[str]:
        words = text.split()
        chunks = []
        current_chunk = []
        current_size = 0

        for word in words:
            if current_size + len(word) > self.chunk_size:
                chunks.append(' '.join(current_chunk))
                current_chunk = [word]
                current_size = len(word)
            else:
                current_chunk.append(word)
                current_size += len(word) + 1

        if current_chunk:
            chunks.append(' '.join(current_chunk))

        return chunks

Step 4: Creating Embeddings

Create src/embeddings_manager.py:

from typing import List
import openai
import numpy as np

class EmbeddingsManager:
    def __init__(self, api_key: str):
        openai.api_key = api_key

    def create_embeddings(self, texts: List[str]) -> List[np.ndarray]:
        embeddings = []
        for text in texts:
            response = openai.embeddings.create(
                model="text-embedding-ada-002",
                input=text
            )
            embeddings.append(np.array(response.data[0].embedding))
        return embeddings

Step 5: Building the Retrieval System

Create src/retrieval_system.py:

import numpy as np
from typing import List, Tuple

class RetrievalSystem:
    def __init__(self, chunks: List[str], embeddings: List[np.ndarray]):
        self.chunks = chunks
        self.embeddings = embeddings

    def find_similar_chunks(self, query_embedding: np.ndarray, top_k: int = 3) -> List[Tuple[str, float]]:
        similarities = []
        for i, embedding in enumerate(self.embeddings):
            similarity = np.dot(query_embedding, embedding) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(embedding)
            )
            similarities.append((self.chunks[i], similarity))

        return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]

Step 6: Connecting with OpenAI

Create src/rag_system.py:

import os
from dotenv import load_dotenv
from typing import List
import openai

from .document_loader import DocumentLoader
from .text_processor import TextProcessor
from .embeddings_manager import EmbeddingsManager
from .retrieval_system import RetrievalSystem

class RAGSystem:
    def __init__(self):
        load_dotenv()
        self.api_key = os.getenv('OPENAI_API_KEY')
        self.loader = DocumentLoader('data/documents')
        self.processor = TextProcessor()
        self.embeddings_manager = EmbeddingsManager(self.api_key)

        # Initialize system
        self.initialize_system()

    def initialize_system(self):
        # Load and process documents
        documents = self.loader.load_documents()
        self.chunks = []
        for doc in documents:
            self.chunks.extend(self.processor.split_into_chunks(doc))

        # Create embeddings
        self.embeddings = self.embeddings_manager.create_embeddings(self.chunks)

        # Initialize retrieval system
        self.retrieval_system = RetrievalSystem(self.chunks, self.embeddings)

    def answer_question(self, question: str) -> str:
        # Get question embedding
        question_embedding = self.embeddings_manager.create_embeddings([question])[0]

        # Get relevant chunks
        relevant_chunks = self.retrieval_system.find_similar_chunks(question_embedding)

        # Prepare context
        context = "\n".join([chunk[0] for chunk in relevant_chunks])

        # Create prompt
        prompt = f"""Context: {context}\n\nQuestion: {question}\n\nAnswer:"""

        # Get response from OpenAI
        response = openai.chat.completions.create(
            model="gpt-4-turbo-preview",
            messages=[
                {"role": "system", "content": "You are a helpful assistant. Use the provided context to answer the question."},
                {"role": "user", "content": prompt}
            ]
        )

        return response.choices[0].message.content

Step 7: Putting It All Together

Here's how to use the system:

Add some test documents to your data/documents folder:

story.txt

Then run a test:

# test.py
from src.rag_system import RAGSystem

# Initialize the RAG system
rag = RAGSystem()

# Ask a question
question = "What was the answer to the guardian’s riddle, and how did it help Kai?"
answer = rag.answer_question(question)
print(answer)

Conclusion

Congratulations! You've built a basic RAG system that can:

Load and process documents
Create embeddings using OpenAI
Find relevant information using similarity search
Generate answers using context

This is just the beginning - you can improve this system by:

Adding better text chunking methods
Implementing caching for embeddings
Adding error handling
Improving the prompt engineering
Adding vector database support

Github Repository

You can find the complete code for this project on GitHub: Python Rag System.

Remember to keep your API key safe and monitor your API usage!

Happy coding! 🚀

How to Create a Web Search Tool Using OpenAI API in Go

Mazyar Yousefiniyae shad — Mon, 27 Jan 2025 05:01:36 +0000

In this tutorial, we will build a simple web search tool in Go using the OpenAI API. This application will utilize OpenAI's capabilities to process search queries and integrate Google Search for retrieving relevant results. By the end of this guide, you will have a functional web search tool to enhance your projects.

Introduction
Prerequisites
Folder Structure
Setting Up the Project
Writing the Search Logic
Testing the Application
Conclusion

Introduction

Web search tools powered by OpenAI offer an intelligent way to interact with search engines and process results. In this tutorial, we will build a Go application that:

Accepts user queries.
Retrieves search results using Google Search.
Processes the results with OpenAI API for summarization.

Prerequisites

Before starting, ensure you have:

Go installed (version 1.19 or higher).
An OpenAI API key.
Access to a Google Search API or a suitable browser tool.
Basic knowledge of Go programming.

Folder Structure

Create the following structure for your project:

websearch-go/
|-- main.go
|-- search/
|   |-- search.go
|-- openai/
    |-- openai.go

Setting Up the Project

Step 1: Initialize the Project

Run the following command to initialize a new Go module:

mkdir websearch-go && cd websearch-go
go mod init websearch-go

Step 2: Install Dependencies

We will use the following libraries:

github.com/joho/godotenv for environment variables.
net/http for HTTP requests.
encoding/json for parsing JSON responses.

Install the required libraries:

go get github.com/joho/godotenv

Step 3: Create a `.env` File

Add your OpenAI API key and Google API key to a .env file:

OPENAI_API_KEY=your_openai_api_key
GOOGLE_API_KEY=your_google_api_key
GOOGLE_SEARCH_ENGINE_ID=your_search_engine_id

Writing the Search Logic

Step 1: Implement the Google Search

Create a new file search/search.go:

package search

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

type GoogleSearchResult struct {
    Items []struct {
        Title       string `json:"title"`
        Link        string `json:"link"`
        Snippet     string `json:"snippet"`
    } `json:"items"`
}

func GoogleSearch(query string) ([]string, error) {
    apiKey := os.Getenv("GOOGLE_API_KEY")
    cx := os.Getenv("GOOGLE_SEARCH_ENGINE_ID")
    url := fmt.Sprintf("https://www.googleapis.com/customsearch/v1?q=%s&key=%s&cx=%s", query, apiKey, cx)

    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result GoogleSearchResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    var links []string
    for _, item := range result.Items {
        links = append(links, fmt.Sprintf("%s: %s", item.Title, item.Link))
    }

    return links, nil
}

Step 2: Integrate OpenAI

Create a new file openai/openai.go:

package openai

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

type OpenAIRequest struct {
    Model       string   `json:"model"`
    Prompt      string   `json:"prompt"`
    MaxTokens   int      `json:"max_tokens"`
    Temperature float64  `json:"temperature"`
}

type OpenAIResponse struct {
    Choices []struct {
        Text string `json:"text"`
    } `json:"choices"`
}

func Summarize(prompt string) (string, error) {
    apiKey := os.Getenv("OPENAI_API_KEY")
    url := "https://api.openai.com/v1/completions"

    requestBody := OpenAIRequest{
        Model:       "text-davinci-003",
        Prompt:      prompt,
        MaxTokens:   150,
        Temperature: 0.7,
    }

    jsonBody, err := json.Marshal(requestBody)
    if err != nil {
        return "", err
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
    if err != nil {
        return "", err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    var response OpenAIResponse
    if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
        return "", err
    }

    if len(response.Choices) > 0 {
        return response.Choices[0].Text, nil
    }

    return "", fmt.Errorf("no response from OpenAI")
}

Step 3: Combine Google Search and OpenAI

In main.go, combine both services:

package main

import (
    "fmt"
    "log"
    "os"

    "websearch-go/openai"
    "websearch-go/search"

    "github.com/joho/godotenv"
)

func main() {
    if err := godotenv.Load(); err != nil {
        log.Fatal("Error loading .env file")
    }

    query := "Latest technology trends"
    fmt.Println("Searching for:", query)

    results, err := search.GoogleSearch(query)
    if err != nil {
        log.Fatal(err)
    }

    for _, result := range results {
        fmt.Println("Result:", result)
    }

    summary, err := openai.Summarize("Summarize these results: \n" + fmt.Sprint(results))
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Summary:", summary)
}

Testing the Application

Run the application using:

go run main.go

You should see search results followed by a summarized output.

Conclusion

In this guide, we created a simple web search tool using Go, OpenAI API, and Google Search. This combination allows us to fetch and process search results intelligently, making it a powerful tool for various applications. Feel free to expand on this by adding a web interface or additional features!

Creating a WebSocket Server in Go with Gorilla

Mazyar Yousefiniyae shad — Sun, 26 Jan 2025 19:59:26 +0000

Creating a WebSocket Server in Go with Gorilla

WebSockets are a powerful way to enable real-time communication between a server and a client. They keep a connection open, allowing messages to be sent back and forth efficiently. In this blog post, we'll build a WebSocket server using Go and the popular Gorilla WebSocket library.

Introduction to WebSockets and Gorilla
Setting Up the Project
Folder Structure
Installing Gorilla WebSocket
Creating the WebSocket Server
Handling Messages
Running the Application
Conclusion
GitHub Repository

Introduction to WebSockets and Gorilla

WebSockets are used for real-time, full-duplex communication between a client and a server. Unlike HTTP, WebSockets allow for continuous data exchange without needing to repeatedly open and close connections.

The Gorilla WebSocket package makes it easy to implement WebSockets in Go. It handles the WebSocket handshake, message reading/writing, and connection management efficiently.

Setting Up the Project

Let’s set up a simple project to demonstrate WebSocket functionality. This project will include:

A WebSocket server that accepts connections.
A client that communicates with the server.

Folder Structure

Here's the folder structure for our project:

websocket-server/
├── main.go           # Entry point of the application
├── handlers/         # Contains WebSocket handlers
│   └── websocket.go  # Handles WebSocket connections and messages
├── static/           # Contains client-side HTML/JS files
│   └── index.html    # A simple client interface
└── go.mod            # Go module file

Installing Gorilla WebSocket

First, we need to install the Gorilla WebSocket package. Run the following command in your terminal:

go get -u github.com/gorilla/websocket

This will add the Gorilla WebSocket library to your project.

Creating the WebSocket Server

Step 1: Write the `main.go`

Create a main.go file in the root of your project:

package main

import (
    "fmt"
    "log"
    "net/http"
    "websocket-server/handlers"
)

func main() {
    http.HandleFunc("/ws", handlers.HandleWebSocket)

    fs := http.FileServer(http.Dir("./static"))
    http.Handle("/", fs)

    port := ":8080"
    fmt.Printf("Server is running on http://localhost%s\n", port)
    log.Fatal(http.ListenAndServe(port, nil))
}

This code sets up an HTTP server, serves static files from the static folder, and handles WebSocket connections at the /ws endpoint.

Step 2: Write the WebSocket Handler

In the handlers folder, create a file named websocket.go:

package handlers

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func HandleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println("Failed to upgrade connection:", err)
        return
    }
    defer conn.Close()

    fmt.Println("Client connected")

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Read error:", err)
            break
        }

        fmt.Printf("Received: %s\n", message)

        if err := conn.WriteMessage(messageType, message); err != nil {
            fmt.Println("Write error:", err)
            break
        }
    }
}

This handler upgrades the HTTP connection to a WebSocket connection, reads messages from the client, and sends them back (echo server).

Handling Messages

The HandleWebSocket function handles incoming messages from the client. It reads the message type and content using conn.ReadMessage() and sends the same message back using conn.WriteMessage().

You can extend this functionality to include broadcasting, storing messages, or handling specific commands.

Running the Application

Step 1: Create a Simple Client

In the static folder, create an index.html file:

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Client</title>
</head>
<body>
    <h1>WebSocket Client</h1>
    <input type="text" id="messageInput" placeholder="Type a message...">
    <button id="sendButton">Send</button>
    <ul id="messages"></ul>

    <script>
        const ws = new WebSocket("ws://localhost:8080/ws");
        const messageInput = document.getElementById("messageInput");
        const sendButton = document.getElementById("sendButton");
        const messages = document.getElementById("messages");

        ws.onmessage = (event) => {
            const li = document.createElement("li");
            li.textContent = `Server: ${event.data}`;
            messages.appendChild(li);
        };

        sendButton.onclick = () => {
            const message = messageInput.value;
            ws.send(message);
            const li = document.createElement("li");
            li.textContent = `You: ${message}`;
            messages.appendChild(li);
            messageInput.value = "";
        };
    </script>
</body>
</html>

This client connects to the WebSocket server, sends messages, and displays received messages.

Step 2: Run the Server

Run the following command in your terminal:

go run main.go

Open your browser and go to http://localhost:8080. You can now send and receive messages in real-time!

Conclusion

In this tutorial, we built a simple WebSocket server using Go and Gorilla WebSocket. WebSockets are an excellent choice for real-time applications like chat apps, live notifications, and gaming.

Feel free to extend this project with advanced features like authentication, message broadcasting, and persistent storage. Happy coding!

GitHub Repository

You can find the complete code for this project on GitHub: WebSocket Server in Go.

How to Build a CRUD App with Golang, Gin, and PostgreSQL

Mazyar Yousefiniyae shad — Sun, 26 Jan 2025 05:08:22 +0000

CRUD (Create, Read, Update, Delete) applications are common when working with databases. In this tutorial, I'll show you how to create a simple CRUD app using Golang, the Gin framework, and PostgreSQL. By the end, you'll have a basic app where you can manage data stored in a PostgreSQL database.

Introduction
Prerequisites
Folder Structure
Setting Up the Project
Creating the Database and Table
Writing the CRUD Handlers
Testing the API
Conclusion

1. Introduction

In this blog post, we’ll use Gin, a lightweight web framework for Golang, to build our API endpoints. The app will connect to a PostgreSQL database, and we’ll use the pgx driver for database interaction.

This tutorial is beginner-friendly and assumes you have basic knowledge of Golang and REST APIs.

2. Prerequisites

Before we start, ensure you have the following installed on your machine:

Golang (1.20 or higher)
PostgreSQL (any version)
Postman or another API testing tool
A code editor (e.g., VS Code)

3. Folder Structure

Here’s the folder structure we’ll use for the project:

crud-app/
├── main.go            # Entry point of the application
├── config/
│   └── database.go    # Database connection setup
├── controllers/
│   └── item.go        # CRUD handlers for the "item" resource
├── models/
│   └── item.go        # Database model for "item"
├── routes/
│   └── routes.go      # API route definitions
├── go.mod             # Go module file
└── go.sum             # Dependency file

This structure is simple but scalable. You can add more resources (e.g., "users" or "orders") later without cluttering the project.

4. Setting Up the Project

First, create the project folder and initialize a new Go module:

mkdir crud-app
cd crud-app
go mod init github.com/yourusername/crud-app

Next, install the required packages:

go get github.com/gin-gonic/gin
go get github.com/jackc/pgx/v5

5. Creating the Database and Table

Create a PostgreSQL database and a table for our app. For example, we’ll use an "items" table:

CREATE DATABASE crud_app;

\c crud_app

CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT,
    price NUMERIC(10, 2)
);

6. Writing the CRUD Handlers

Setting Up the Database Connection

In config/database.go:

package config

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/jackc/pgx/v5/stdlib"
)

var DB *sql.DB

func ConnectDatabase() {
    var err error
    dsn := "postgres://username:password@localhost:5432/crud_app"
    DB, err = sql.Open("pgx", dsn)
    if err != nil {
        log.Fatalf("Could not connect to the database: %v", err)
    }

    fmt.Println("Database connected!")
}

Update the dsn string with your PostgreSQL username and password.

Writing the Model

In models/item.go:

package models

type Item struct {
    ID          int     `json:"id"`
    Name        string  `json:"name"`
    Description string  `json:"description"`
    Price       float64 `json:"price"`
}

Writing the Handlers

In controllers/item.go:

package controllers

import (
    "crud-app/config"
    "crud-app/models"
    "github.com/gin-gonic/gin"
    "net/http"
)

// Create a new item
func CreateItem(c *gin.Context) {
    var item models.Item
    if err := c.ShouldBindJSON(&item); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    query := "INSERT INTO items (name, description, price) VALUES ($1, $2, $3) RETURNING id"
    err := config.DB.QueryRow(query, item.Name, item.Description, item.Price).Scan(&item.ID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create item"})
        return
    }

    c.JSON(http.StatusCreated, item)
}

You can implement similar handlers for reading, updating, and deleting items.

Defining Routes

In routes/routes.go:

package routes

import (
    "crud-app/controllers"
    "github.com/gin-gonic/gin"
)

func SetupRoutes(router *gin.Engine) {
    router.POST("/items", controllers.CreateItem)
    // Add more routes for Read, Update, Delete
}

Main File

In main.go:

package main

import (
    "crud-app/config"
    "crud-app/routes"
    "github.com/gin-gonic/gin"
)

func main() {
    config.ConnectDatabase()

    r := gin.Default()
    routes.SetupRoutes(r)

    r.Run(":8080") // Start the server on port 8080
}

7. Testing the API

Start the server:

go run main.go

Use Postman or cURL to test the endpoints. For example, to create an item:

POST http://localhost:8080/items

Request body:

{
  "name": "Laptop",
  "description": "A powerful laptop",
  "price": 1200.50
}

8. Conclusion

Congratulations! You’ve built a basic CRUD app with Golang, Gin, and PostgreSQL. This structure is easy to expand as your project grows. You can add more features like authentication, logging, or middleware.

Let me know if you’d like more detailed steps or additional features for your project!

DEV Community: Mazyar Yousefiniyae shad

I Built an AI Gateway That Cuts LLM Costs by 60% - Here's How

I Built an AI Gateway That Cuts LLM Costs by 60% - Here's How

🎯 The Problem

💡 The Solution: An Intelligent Proxy

🏗️ Architecture Overview

🚀 Key Features

1. Smart Caching

2. Intelligent Model Routing

3. Automatic Fallback

4. Streaming Support

5. Cost Analytics

💻 Show Me The Code

Drop-In Replacement

📊 Real-World Results

🛠️ Tech Stack

🚀 Getting Started

🔐 Security Features

📈 What's Next?

🤝 Contributing

🎯 Key Takeaways

🔗 Links

💬 Discussion

AI #OpenAI #Golang #DevOps #CloudCosts #MachineLearning #ChatGPT

Building Your First RAG System with Python and OpenAI

Table of Contents

What You'll Learn

Project Setup

Step 1: Setting Up the Environment

Step 2: Document Loading

Step 3: Text Processing

Step 4: Creating Embeddings

Step 5: Building the Retrieval System

Step 6: Connecting with OpenAI

Step 7: Putting It All Together

Conclusion

Github Repository

How to Create a Web Search Tool Using OpenAI API in Go

Table of Contents

Introduction

Prerequisites

Folder Structure

Setting Up the Project

Step 1: Initialize the Project

Step 2: Install Dependencies

Step 3: Create a .env File

Writing the Search Logic

Step 1: Implement the Google Search

Step 2: Integrate OpenAI

Step 3: Combine Google Search and OpenAI

Testing the Application

Conclusion

Creating a WebSocket Server in Go with Gorilla

Creating a WebSocket Server in Go with Gorilla

Table of Contents

Introduction to WebSockets and Gorilla

Setting Up the Project

Folder Structure

Installing Gorilla WebSocket

Creating the WebSocket Server

Step 1: Write the main.go

Step 2: Write the WebSocket Handler

Handling Messages

Running the Application

Step 1: Create a Simple Client

Step 2: Run the Server

Conclusion

GitHub Repository

How to Build a CRUD App with Golang, Gin, and PostgreSQL

Table of Contents

1. Introduction

2. Prerequisites

3. Folder Structure

4. Setting Up the Project

5. Creating the Database and Table

6. Writing the CRUD Handlers

Setting Up the Database Connection

Writing the Model

Writing the Handlers

Defining Routes

Step 3: Create a `.env` File

Step 1: Write the `main.go`