نحوه ایجاد یک ابزار جستجوی وب با استفاده از OpenAi API در GO

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

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

go get github.com/joho/godotenv

OPENAI_API_KEY=your_openai_api_key
GOOGLE_API_KEY=your_google_api_key
GOOGLE_SEARCH_ENGINE_ID=your_search_engine_id

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
}

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")
}

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)
}

go run main.go