#67: Introducing embedding API

.gitignore

@@ -1,9 +1,11 @@
 .idea
 dist
 .env
+.env.bak
 config.yaml
 bin
 glide
+glide.exe
 tmp
 coverage.txt
 precommit.txt

config.dev.yaml

@@ -8,5 +8,6 @@ routers:
     - id: default
       models:
         - id: openai
-          openai:
-            api_key: "${env:OPENAI_API_KEY}"
+          provider:
+            openai:
+              api_key: "${env:OPENAI_API_KEY}"

config.sample.yaml

@@ -6,3 +6,12 @@ telemetry:
 #api:
 #  http:
 #    ...
+
+routers:
+  language:
+    - id: default
+      models:
+        - id: openai
+          provider:
+            openai:
+              api_key: "${env:OPENAI_API_KEY}"

main.go

@@ -3,7 +3,7 @@ package main
 import (
 	"log"
 
-	"github.com/EinStack/glide/pkg/cmd"
+	"github.com/EinStack/glide/cmd"
 )
 
 //	@title			Glide

pkg/api/http/handlers.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"sync"
 
-	"github.com/EinStack/glide/pkg/api/schemas"
-	"github.com/EinStack/glide/pkg/routers"
+	"github.com/EinStack/glide/pkg/api/schema"
+
+	"github.com/EinStack/glide/pkg/router"
+
 	"github.com/EinStack/glide/pkg/telemetry"
 	"github.com/gofiber/contrib/websocket"
 	"github.com/gofiber/fiber/v2"
@@ -31,38 +33,38 @@ type Handler = func(c *fiber.Ctx) error
 //	@Failure		400	{object}	schemas.Error
 //	@Failure		404	{object}	schemas.Error
 //	@Router			/v1/language/{router}/chat [POST]
-func LangChatHandler(routerManager *routers.RouterManager) Handler {
+func LangChatHandler(routerManager *router.Manager) Handler {
 	return func(c *fiber.Ctx) error {
 		if !c.Is("json") {
-			return c.Status(fiber.StatusBadRequest).JSON(schemas.ErrUnsupportedMediaType)
+			return c.Status(fiber.StatusBadRequest).JSON(schema.ErrUnsupportedMediaType)
 		}
 
 		// Unmarshal request body
-		req := schemas.GetChatRequest()
-		defer schemas.ReleaseChatRequest(req)
+		req := schema.GetChatRequest()
+		defer schema.ReleaseChatRequest(req)
 
 		err := c.BodyParser(&req)
 		if err != nil {
-			return c.Status(fiber.StatusBadRequest).JSON(schemas.NewPayloadParseErr(err))
+			return c.Status(fiber.StatusBadRequest).JSON(schema.NewPayloadParseErr(err))
 		}
 
 		// Get router ID from path
 		routerID := c.Params("router")
 
-		router, err := routerManager.GetLangRouter(routerID)
+		r, err := routerManager.GetLangRouter(routerID)
 		if err != nil {
-			httpErr := schemas.FromErr(err)
+			httpErr := schema.FromErr(err)
 
 			return c.Status(httpErr.Status).JSON(httpErr)
 		}
 
 		// Chat with router
-		resp := schemas.GetChatResponse()
-		defer schemas.ReleaseChatResponse(resp)
+		resp := schema.GetChatResponse()
+		defer schema.ReleaseChatResponse(resp)
 
-		resp, err = router.Chat(c.Context(), req)
+		resp, err = r.Chat(c.Context(), req)
 		if err != nil {
-			httpErr := schemas.FromErr(err)
+			httpErr := schema.FromErr(err)
 
 			return c.Status(httpErr.Status).JSON(httpErr)
 		}
@@ -72,14 +74,14 @@ func LangChatHandler(routerManager *routers.RouterManager) Handler {
 	}
 }
 
-func LangStreamRouterValidator(routerManager *routers.RouterManager) Handler {
+func LangStreamRouterValidator(routerManager *router.Manager) Handler {
 	return func(c *fiber.Ctx) error {
 		if websocket.IsWebSocketUpgrade(c) {
 			routerID := c.Params("router")
 
 			_, err := routerManager.GetLangRouter(routerID)
 			if err != nil {
-				httpErr := schemas.FromErr(err)
+				httpErr := schema.FromErr(err)
 
 				return c.Status(httpErr.Status).JSON(httpErr)
 			}
@@ -107,7 +109,7 @@ func LangStreamRouterValidator(routerManager *routers.RouterManager) Handler {
 //	@Failure		426
 //	@Failure		404	{object}	schemas.Error
 //	@Router			/v1/language/{router}/chatStream [GET]
-func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *routers.RouterManager) Handler {
+func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *router.Manager) Handler {
 	// TODO: expose websocket connection configs https://github.com/gofiber/contrib/tree/main/websocket
 	return websocket.New(func(c *websocket.Conn) {
 		routerID := c.Params("router")
@@ -118,9 +120,9 @@ func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *routers.Rout
 			wg  sync.WaitGroup
 		)
 
-		chatStreamC := make(chan *schemas.ChatStreamMessage)
+		chatStreamC := make(chan *schema.ChatStreamMessage)
 
-		router, _ := routerManager.GetLangRouter(routerID)
+		r, _ := routerManager.GetLangRouter(routerID)
 
 		defer close(chatStreamC)
 		defer c.Conn.Close()
@@ -138,7 +140,7 @@ func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *routers.Rout
 		}()
 
 		for {
-			var chatRequest schemas.ChatStreamRequest
+			var chatRequest schema.ChatStreamRequest
 
 			if err = c.ReadJSON(&chatRequest); err != nil {
 				// TODO: handle bad request schemas gracefully and return back validation errors
@@ -154,10 +156,10 @@ func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *routers.Rout
 			// TODO: handle termination gracefully
 			wg.Add(1)
 
-			go func(chatRequest schemas.ChatStreamRequest) {
+			go func(chatRequest schema.ChatStreamRequest) {
 				defer wg.Done()
 
-				router.ChatStream(context.Background(), &chatRequest, chatStreamC)
+				r.ChatStream(context.Background(), &chatRequest, chatStreamC)
 			}(chatRequest)
 		}
 
@@ -175,16 +177,16 @@ func LangStreamChatHandler(tel *telemetry.Telemetry, routerManager *routers.Rout
 //	@Produce		json
 //	@Success		200	{object}	schemas.RouterListSchema
 //	@Router			/v1/language/ [GET]
-func LangRoutersHandler(routerManager *routers.RouterManager) Handler {
+func LangRoutersHandler(routerManager *router.Manager) Handler {
 	return func(c *fiber.Ctx) error {
 		configuredRouters := routerManager.GetLangRouters()
 		cfgs := make([]interface{}, 0, len(configuredRouters)) // opaque by design
 
-		for _, router := range configuredRouters {
-			cfgs = append(cfgs, router.Config)
+		for _, r := range configuredRouters {
+			cfgs = append(cfgs, r.Config)
 		}
 
-		return c.Status(fiber.StatusOK).JSON(schemas.RouterListSchema{Routers: cfgs})
+		return c.Status(fiber.StatusOK).JSON(schema.RouterListSchema{Routers: cfgs})
 	}
 }
 
@@ -199,9 +201,9 @@ func LangRoutersHandler(routerManager *routers.RouterManager) Handler {
 //	@Success	200	{object}	schemas.HealthSchema
 //	@Router		/v1/health/ [get]
 func HealthHandler(c *fiber.Ctx) error {
-	return c.Status(fiber.StatusOK).JSON(schemas.HealthSchema{Healthy: true})
+	return c.Status(fiber.StatusOK).JSON(schema.HealthSchema{Healthy: true})
 }
 
 func NotFoundHandler(c *fiber.Ctx) error {
-	return c.Status(fiber.StatusNotFound).JSON(schemas.ErrRouteNotFound)
+	return c.Status(fiber.StatusNotFound).JSON(schema.ErrRouteNotFound)
 }

pkg/api/http/server.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/EinStack/glide/pkg/router"
+
 	"github.com/gofiber/contrib/otelfiber"
 
 	"github.com/gofiber/swagger"
@@ -17,19 +19,17 @@ import (
 
 	"github.com/gofiber/fiber/v2"
 
-	"github.com/EinStack/glide/pkg/routers"
-
 	"github.com/EinStack/glide/pkg/telemetry"
 )
 
 type Server struct {
 	config        *ServerConfig
 	telemetry     *telemetry.Telemetry
-	routerManager *routers.RouterManager
+	routerManager *router.Manager
 	server        *fiber.App
 }
 
-func NewServer(config *ServerConfig, tel *telemetry.Telemetry, routerManager *routers.RouterManager) (*Server, error) {
+func NewServer(config *ServerConfig, tel *telemetry.Telemetry, routerManager *router.Manager) (*Server, error) {
 	srv := config.ToServer()
 
 	return &Server{

pkg/api/schemas/chat.go → pkg/api/schema/chat.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 // ChatRequest defines Glide's Chat Request Schema unified across all language models
 type ChatRequest struct {

pkg/api/schemas/chat_stream.go → pkg/api/schema/chat_stream.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 import "time"
 

pkg/api/schemas/chat_test.go → pkg/api/schema/chat_test.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 import (
 	"testing"

pkg/api/schema/embed.go

@@ -0,0 +1,9 @@
+package schema
+
+type EmbedRequest struct {
+	// TODO: implement
+}
+
+type EmbedResponse struct {
+	// TODO: implement
+}

pkg/api/schemas/errors.go → pkg/api/schema/errors.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 import (
 	"fmt"

pkg/api/schemas/health_checks.go → pkg/api/schema/health.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 type HealthSchema struct {
 	Healthy bool `json:"healthy"`

pkg/api/schemas/pool.go → pkg/api/schema/pool.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 import (
 	"sync"

pkg/api/schemas/routers.go → pkg/api/schema/routers.go

@@ -1,4 +1,4 @@
-package schemas
+package schema
 
 // RouterListSchema returns list of active configured routers.
 //

pkg/api/servers.go

@@ -4,9 +4,9 @@ import (
 	"context"
 	"sync"
 
-	"go.uber.org/zap"
+	"github.com/EinStack/glide/pkg/router"
 
-	"github.com/EinStack/glide/pkg/routers"
+	"go.uber.org/zap"
 
 	"github.com/EinStack/glide/pkg/telemetry"
 
@@ -19,7 +19,7 @@ type ServerManager struct {
 	telemetry  *telemetry.Telemetry
 }
 
-func NewServerManager(cfg *Config, tel *telemetry.Telemetry, router *routers.RouterManager) (*ServerManager, error) {
+func NewServerManager(cfg *Config, tel *telemetry.Telemetry, router *router.Manager) (*ServerManager, error) {
 	httpServer, err := http.NewServer(cfg.HTTP, tel, router)
 	if err != nil {
 		return nil, err

pkg/clients/stream.go

@@ -0,0 +1,29 @@
+package clients
+
+import "github.com/EinStack/glide/pkg/api/schema"
+
+type ChatStream interface {
+	Open() error
+	Recv() (*schema.ChatStreamChunk, error)
+	Close() error
+}
+
+type ChatStreamResult struct {
+	chunk *schema.ChatStreamChunk
+	err   error
+}
+
+func (r *ChatStreamResult) Chunk() *schema.ChatStreamChunk {
+	return r.chunk
+}
+
+func (r *ChatStreamResult) Error() error {
+	return r.err
+}
+
+func NewChatStreamResult(chunk *schema.ChatStreamChunk, err error) *ChatStreamResult {
+	return &ChatStreamResult{
+		chunk: chunk,
+		err:   err,
+	}
+}

pkg/config/config.go

@@ -1,18 +1,16 @@
 package config
 
 import (
-	"github.com/EinStack/glide/pkg/telemetry"
-
-	"github.com/EinStack/glide/pkg/routers"
-
 	"github.com/EinStack/glide/pkg/api"
+	"github.com/EinStack/glide/pkg/router"
+	"github.com/EinStack/glide/pkg/telemetry"
 )
 
 // Config is a general top-level Glide configuration
 type Config struct {
-	Telemetry *telemetry.Config `yaml:"telemetry" validate:"required"`
-	API       *api.Config       `yaml:"api" validate:"required"`
-	Routers   routers.Config    `yaml:"routers" validate:"required"`
+	Telemetry *telemetry.Config    `yaml:"telemetry" validate:"required"`
+	API       *api.Config          `yaml:"api" validate:"required"`
+	Routers   router.RoutersConfig `yaml:"routers" validate:"required"`
 }
 
 func DefaultConfig() *Config {