/chatgpt-bridge

/chatgpt-bridge <action> [options]

# Basic chat with default model (gpt-4o)
/chatgpt-bridge chat "Explain pattern matching in Elixir"

# With specific model and streaming
/chatgpt-bridge chat --model gpt-4o-mini --stream "Write a detailed OTP explanation"

# With system prompt override
/chatgpt-bridge chat --system "You are an Elixir expert" "How do I structure an umbrella app?"

# Multi-turn conversation with session persistence
/chatgpt-bridge chat --session my-session "Let's discuss GenServers"
/chatgpt-bridge chat --session my-session "How do I add state?"

# Generate text embeddings for semantic search
/chatgpt-bridge embed "GenServer state management"

# Single completion without conversation context
/chatgpt-bridge complete --max-tokens 100 "Continue this code: def foo do"

# Streaming response for long content
/chatgpt-bridge stream "Write a comprehensive guide to supervision trees"

# List available models
/chatgpt-bridge models

# Check API health and connectivity
/chatgpt-bridge health --verbose

# Track API costs
/chatgpt-bridge cost --period week --by-model

# Manage configuration
/chatgpt-bridge config --validate

# Chat with tool/function calling enabled
/chatgpt-bridge chat --tools file_search,grep_search "Find all GenServer modules"

# List available tools
/chatgpt-bridge tools --list

# Test specific tool execution
/chatgpt-bridge tools --test grep_search --args '{"query": "GenServer"}'

defmodule Prismatic.LLM.Bridges.ChatGPTBridge do
  @moduledoc """
  ChatGPT/OpenAI API bridge with connection pooling, rate limiting,
  circuit breaking, and cost tracking. Conforms to unified LLM interface.
  """

  use GenServer

  @default_model "gpt-4o"
  @rate_limit_rpm 500
  @rate_limit_tpm 30_000

  @spec chat(String.t(), keyword()) :: {:ok, Response.t()} | {:error, term()}
  def chat(prompt, opts \\ []) do
    model = Keyword.get(opts, :model, @default_model)
    temperature = Keyword.get(opts, :temperature, 0.7)
    stream = Keyword.get(opts, :stream, false)

    with :ok <- check_rate_limit(),
         :ok <- check_circuit_breaker(),
         {:ok, response} <- execute_chat(prompt, model, temperature, stream, opts),
         :ok <- track_cost(response) do
      {:ok, response}
    end
  end

  defp execute_chat(prompt, model, temperature, true, opts) do
    messages = build_messages(prompt, opts)

    Prismatic.LLM.OpenAI.Client.stream_chat(%{
      model: model,
      messages: messages,
      temperature: temperature,
      max_tokens: Keyword.get(opts, :max_tokens, 4096),
      tools: resolve_tools(Keyword.get(opts, :tools))
    })
  end

  defp track_cost(%{usage: usage, model: model}) do
    pricing = Prismatic.LLM.Pricing.get(model)
    cost = usage.prompt_tokens * pricing.input + usage.completion_tokens * pricing.output
    Prismatic.LLM.CostTracker.record(model, cost, usage)
    :ok
  end
end

Related Commands