-- | Search
module Pinecone.Search
    ( -- * Main types
      SearchWithVector(..)
    , _SearchWithVector
    , Matches(..)
    , SearchWithText(..)
    , _SearchWithText
    , Hits(..)

     -- * Other types
    , Match(..)
    , Query(..)
    , _Query
    , VectorQuery(..)
    , Rerank(..)
    , Hit(..)
    , Usage(..)

      -- * Servant
    , API
    ) where

import Prelude hiding (filter)
import Pinecone.Embed (Input(..))
import Pinecone.Metadata (Filter, Scalar)
import Pinecone.Prelude
import Pinecone.Vectors (Namespace, SparseValues)

-- | Request body for @\/query@
data SearchWithVector = SearchWithVector
    { SearchWithVector -> Natural
topK :: Natural
    , SearchWithVector -> Maybe Namespace
namespace :: Maybe Namespace
    , SearchWithVector -> Maybe Filter
filter :: Maybe Filter
    , SearchWithVector -> Maybe Bool
includeValues :: Maybe Bool
    , SearchWithVector -> Maybe Bool
includeMetadata :: Maybe Bool
    , SearchWithVector -> Maybe (Vector Double)
vector :: Maybe (Vector Double)
    , SearchWithVector -> Maybe SparseValues
sparseVector :: Maybe SparseValues
    , SearchWithVector -> Maybe Text
id :: Maybe Text
    } deriving stock (SearchWithVector -> SearchWithVector -> Bool
(SearchWithVector -> SearchWithVector -> Bool)
-> (SearchWithVector -> SearchWithVector -> Bool)
-> Eq SearchWithVector
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SearchWithVector -> SearchWithVector -> Bool
== :: SearchWithVector -> SearchWithVector -> Bool
$c/= :: SearchWithVector -> SearchWithVector -> Bool
/= :: SearchWithVector -> SearchWithVector -> Bool
Eq, (forall x. SearchWithVector -> Rep SearchWithVector x)
-> (forall x. Rep SearchWithVector x -> SearchWithVector)
-> Generic SearchWithVector
forall x. Rep SearchWithVector x -> SearchWithVector
forall x. SearchWithVector -> Rep SearchWithVector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SearchWithVector -> Rep SearchWithVector x
from :: forall x. SearchWithVector -> Rep SearchWithVector x
$cto :: forall x. Rep SearchWithVector x -> SearchWithVector
to :: forall x. Rep SearchWithVector x -> SearchWithVector
Generic, Int -> SearchWithVector -> ShowS
[SearchWithVector] -> ShowS
SearchWithVector -> String
(Int -> SearchWithVector -> ShowS)
-> (SearchWithVector -> String)
-> ([SearchWithVector] -> ShowS)
-> Show SearchWithVector
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SearchWithVector -> ShowS
showsPrec :: Int -> SearchWithVector -> ShowS
$cshow :: SearchWithVector -> String
show :: SearchWithVector -> String
$cshowList :: [SearchWithVector] -> ShowS
showList :: [SearchWithVector] -> ShowS
Show)
      deriving anyclass (Maybe SearchWithVector
Value -> Parser [SearchWithVector]
Value -> Parser SearchWithVector
(Value -> Parser SearchWithVector)
-> (Value -> Parser [SearchWithVector])
-> Maybe SearchWithVector
-> FromJSON SearchWithVector
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SearchWithVector
parseJSON :: Value -> Parser SearchWithVector
$cparseJSONList :: Value -> Parser [SearchWithVector]
parseJSONList :: Value -> Parser [SearchWithVector]
$comittedField :: Maybe SearchWithVector
omittedField :: Maybe SearchWithVector
FromJSON, [SearchWithVector] -> Value
[SearchWithVector] -> Encoding
SearchWithVector -> Bool
SearchWithVector -> Value
SearchWithVector -> Encoding
(SearchWithVector -> Value)
-> (SearchWithVector -> Encoding)
-> ([SearchWithVector] -> Value)
-> ([SearchWithVector] -> Encoding)
-> (SearchWithVector -> Bool)
-> ToJSON SearchWithVector
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SearchWithVector -> Value
toJSON :: SearchWithVector -> Value
$ctoEncoding :: SearchWithVector -> Encoding
toEncoding :: SearchWithVector -> Encoding
$ctoJSONList :: [SearchWithVector] -> Value
toJSONList :: [SearchWithVector] -> Value
$ctoEncodingList :: [SearchWithVector] -> Encoding
toEncodingList :: [SearchWithVector] -> Encoding
$comitField :: SearchWithVector -> Bool
omitField :: SearchWithVector -> Bool
ToJSON)

-- | Default `SearchWithVector`
_SearchWithVector :: SearchWithVector
_SearchWithVector :: SearchWithVector
_SearchWithVector = SearchWithVector
    { $sel:namespace:SearchWithVector :: Maybe Namespace
namespace = Maybe Namespace
forall a. Maybe a
Nothing
    , $sel:filter:SearchWithVector :: Maybe Filter
filter = Maybe Filter
forall a. Maybe a
Nothing
    , $sel:includeValues:SearchWithVector :: Maybe Bool
includeValues = Maybe Bool
forall a. Maybe a
Nothing
    , $sel:includeMetadata:SearchWithVector :: Maybe Bool
includeMetadata = Maybe Bool
forall a. Maybe a
Nothing
    , $sel:vector:SearchWithVector :: Maybe (Vector Double)
vector = Maybe (Vector Double)
forall a. Maybe a
Nothing
    , $sel:sparseVector:SearchWithVector :: Maybe SparseValues
sparseVector = Maybe SparseValues
forall a. Maybe a
Nothing
    , $sel:id:SearchWithVector :: Maybe Text
id = Maybe Text
forall a. Maybe a
Nothing
    }

-- | Response body for @\/query@
data Matches = Matches
    { Matches -> Vector Match
matches :: Vector Match
    , Matches -> Namespace
namespace :: Namespace
    , Matches -> Usage
usage :: Usage
    } deriving stock (Matches -> Matches -> Bool
(Matches -> Matches -> Bool)
-> (Matches -> Matches -> Bool) -> Eq Matches
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Matches -> Matches -> Bool
== :: Matches -> Matches -> Bool
$c/= :: Matches -> Matches -> Bool
/= :: Matches -> Matches -> Bool
Eq, (forall x. Matches -> Rep Matches x)
-> (forall x. Rep Matches x -> Matches) -> Generic Matches
forall x. Rep Matches x -> Matches
forall x. Matches -> Rep Matches x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Matches -> Rep Matches x
from :: forall x. Matches -> Rep Matches x
$cto :: forall x. Rep Matches x -> Matches
to :: forall x. Rep Matches x -> Matches
Generic, Int -> Matches -> ShowS
[Matches] -> ShowS
Matches -> String
(Int -> Matches -> ShowS)
-> (Matches -> String) -> ([Matches] -> ShowS) -> Show Matches
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Matches -> ShowS
showsPrec :: Int -> Matches -> ShowS
$cshow :: Matches -> String
show :: Matches -> String
$cshowList :: [Matches] -> ShowS
showList :: [Matches] -> ShowS
Show)
      deriving anyclass (Maybe Matches
Value -> Parser [Matches]
Value -> Parser Matches
(Value -> Parser Matches)
-> (Value -> Parser [Matches]) -> Maybe Matches -> FromJSON Matches
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Matches
parseJSON :: Value -> Parser Matches
$cparseJSONList :: Value -> Parser [Matches]
parseJSONList :: Value -> Parser [Matches]
$comittedField :: Maybe Matches
omittedField :: Maybe Matches
FromJSON, [Matches] -> Value
[Matches] -> Encoding
Matches -> Bool
Matches -> Value
Matches -> Encoding
(Matches -> Value)
-> (Matches -> Encoding)
-> ([Matches] -> Value)
-> ([Matches] -> Encoding)
-> (Matches -> Bool)
-> ToJSON Matches
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Matches -> Value
toJSON :: Matches -> Value
$ctoEncoding :: Matches -> Encoding
toEncoding :: Matches -> Encoding
$ctoJSONList :: [Matches] -> Value
toJSONList :: [Matches] -> Value
$ctoEncodingList :: [Matches] -> Encoding
toEncodingList :: [Matches] -> Encoding
$comitField :: Matches -> Bool
omitField :: Matches -> Bool
ToJSON)

-- | A search request for records in a specific namespace.
data SearchWithText = SearchWithText
    { SearchWithText -> Query
query :: Query
    , SearchWithText -> Maybe (Vector Text)
fields :: Maybe (Vector Text)
    , SearchWithText -> Maybe Rerank
rerank :: Maybe Rerank
    } deriving stock (SearchWithText -> SearchWithText -> Bool
(SearchWithText -> SearchWithText -> Bool)
-> (SearchWithText -> SearchWithText -> Bool) -> Eq SearchWithText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SearchWithText -> SearchWithText -> Bool
== :: SearchWithText -> SearchWithText -> Bool
$c/= :: SearchWithText -> SearchWithText -> Bool
/= :: SearchWithText -> SearchWithText -> Bool
Eq, (forall x. SearchWithText -> Rep SearchWithText x)
-> (forall x. Rep SearchWithText x -> SearchWithText)
-> Generic SearchWithText
forall x. Rep SearchWithText x -> SearchWithText
forall x. SearchWithText -> Rep SearchWithText x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SearchWithText -> Rep SearchWithText x
from :: forall x. SearchWithText -> Rep SearchWithText x
$cto :: forall x. Rep SearchWithText x -> SearchWithText
to :: forall x. Rep SearchWithText x -> SearchWithText
Generic, Int -> SearchWithText -> ShowS
[SearchWithText] -> ShowS
SearchWithText -> String
(Int -> SearchWithText -> ShowS)
-> (SearchWithText -> String)
-> ([SearchWithText] -> ShowS)
-> Show SearchWithText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SearchWithText -> ShowS
showsPrec :: Int -> SearchWithText -> ShowS
$cshow :: SearchWithText -> String
show :: SearchWithText -> String
$cshowList :: [SearchWithText] -> ShowS
showList :: [SearchWithText] -> ShowS
Show)
      deriving anyclass (Maybe SearchWithText
Value -> Parser [SearchWithText]
Value -> Parser SearchWithText
(Value -> Parser SearchWithText)
-> (Value -> Parser [SearchWithText])
-> Maybe SearchWithText
-> FromJSON SearchWithText
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SearchWithText
parseJSON :: Value -> Parser SearchWithText
$cparseJSONList :: Value -> Parser [SearchWithText]
parseJSONList :: Value -> Parser [SearchWithText]
$comittedField :: Maybe SearchWithText
omittedField :: Maybe SearchWithText
FromJSON, [SearchWithText] -> Value
[SearchWithText] -> Encoding
SearchWithText -> Bool
SearchWithText -> Value
SearchWithText -> Encoding
(SearchWithText -> Value)
-> (SearchWithText -> Encoding)
-> ([SearchWithText] -> Value)
-> ([SearchWithText] -> Encoding)
-> (SearchWithText -> Bool)
-> ToJSON SearchWithText
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SearchWithText -> Value
toJSON :: SearchWithText -> Value
$ctoEncoding :: SearchWithText -> Encoding
toEncoding :: SearchWithText -> Encoding
$ctoJSONList :: [SearchWithText] -> Value
toJSONList :: [SearchWithText] -> Value
$ctoEncodingList :: [SearchWithText] -> Encoding
toEncodingList :: [SearchWithText] -> Encoding
$comitField :: SearchWithText -> Bool
omitField :: SearchWithText -> Bool
ToJSON)

-- | Default `SearchWithText`
_SearchWithText :: SearchWithText
_SearchWithText :: SearchWithText
_SearchWithText = SearchWithText
    { $sel:fields:SearchWithText :: Maybe (Vector Text)
fields = Maybe (Vector Text)
forall a. Maybe a
Nothing
    , $sel:rerank:SearchWithText :: Maybe Rerank
rerank = Maybe Rerank
forall a. Maybe a
Nothing
    }

-- | A successful search namespace response.
data Hits = Hits
    { Hits -> Usage
usage :: Usage
    , Hits -> Vector Hit
hits :: Vector Hit
    } deriving stock (Hits -> Hits -> Bool
(Hits -> Hits -> Bool) -> (Hits -> Hits -> Bool) -> Eq Hits
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Hits -> Hits -> Bool
== :: Hits -> Hits -> Bool
$c/= :: Hits -> Hits -> Bool
/= :: Hits -> Hits -> Bool
Eq, (forall x. Hits -> Rep Hits x)
-> (forall x. Rep Hits x -> Hits) -> Generic Hits
forall x. Rep Hits x -> Hits
forall x. Hits -> Rep Hits x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Hits -> Rep Hits x
from :: forall x. Hits -> Rep Hits x
$cto :: forall x. Rep Hits x -> Hits
to :: forall x. Rep Hits x -> Hits
Generic, Int -> Hits -> ShowS
[Hits] -> ShowS
Hits -> String
(Int -> Hits -> ShowS)
-> (Hits -> String) -> ([Hits] -> ShowS) -> Show Hits
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Hits -> ShowS
showsPrec :: Int -> Hits -> ShowS
$cshow :: Hits -> String
show :: Hits -> String
$cshowList :: [Hits] -> ShowS
showList :: [Hits] -> ShowS
Show)

instance FromJSON Hits where
    parseJSON :: Value -> Parser Hits
parseJSON Value
value = do
        Hits_{Usage
Result
result :: Result
usage :: Usage
$sel:result:Hits_ :: Hits_ -> Result
$sel:usage:Hits_ :: Hits_ -> Usage
..} <- Value -> Parser Hits_
forall a. FromJSON a => Value -> Parser a
parseJSON Value
value

        let Result{Vector Hit
hits :: Vector Hit
$sel:hits:Result :: Result -> Vector Hit
..} = Result
result

        Hits -> Parser Hits
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return Hits{Vector Hit
Usage
$sel:usage:Hits :: Usage
$sel:hits:Hits :: Vector Hit
usage :: Usage
hits :: Vector Hit
..}

instance ToJSON Hits where
    toJSON :: Hits -> Value
toJSON Hits{Vector Hit
Usage
$sel:usage:Hits :: Hits -> Usage
$sel:hits:Hits :: Hits -> Vector Hit
usage :: Usage
hits :: Vector Hit
..} = Hits_ -> Value
forall a. ToJSON a => a -> Value
toJSON Hits_{Usage
Result
$sel:result:Hits_ :: Result
$sel:usage:Hits_ :: Usage
usage :: Usage
result :: Result
..}
      where
        result :: Result
result = Result{Vector Hit
$sel:hits:Result :: Vector Hit
hits :: Vector Hit
..}

data Hits_ = Hits_
    { Hits_ -> Result
result :: Result
    , Hits_ -> Usage
usage :: Usage
    } deriving stock (Hits_ -> Hits_ -> Bool
(Hits_ -> Hits_ -> Bool) -> (Hits_ -> Hits_ -> Bool) -> Eq Hits_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Hits_ -> Hits_ -> Bool
== :: Hits_ -> Hits_ -> Bool
$c/= :: Hits_ -> Hits_ -> Bool
/= :: Hits_ -> Hits_ -> Bool
Eq, (forall x. Hits_ -> Rep Hits_ x)
-> (forall x. Rep Hits_ x -> Hits_) -> Generic Hits_
forall x. Rep Hits_ x -> Hits_
forall x. Hits_ -> Rep Hits_ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Hits_ -> Rep Hits_ x
from :: forall x. Hits_ -> Rep Hits_ x
$cto :: forall x. Rep Hits_ x -> Hits_
to :: forall x. Rep Hits_ x -> Hits_
Generic, Int -> Hits_ -> ShowS
[Hits_] -> ShowS
Hits_ -> String
(Int -> Hits_ -> ShowS)
-> (Hits_ -> String) -> ([Hits_] -> ShowS) -> Show Hits_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Hits_ -> ShowS
showsPrec :: Int -> Hits_ -> ShowS
$cshow :: Hits_ -> String
show :: Hits_ -> String
$cshowList :: [Hits_] -> ShowS
showList :: [Hits_] -> ShowS
Show)
      deriving anyclass (Maybe Hits_
Value -> Parser [Hits_]
Value -> Parser Hits_
(Value -> Parser Hits_)
-> (Value -> Parser [Hits_]) -> Maybe Hits_ -> FromJSON Hits_
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Hits_
parseJSON :: Value -> Parser Hits_
$cparseJSONList :: Value -> Parser [Hits_]
parseJSONList :: Value -> Parser [Hits_]
$comittedField :: Maybe Hits_
omittedField :: Maybe Hits_
FromJSON, [Hits_] -> Value
[Hits_] -> Encoding
Hits_ -> Bool
Hits_ -> Value
Hits_ -> Encoding
(Hits_ -> Value)
-> (Hits_ -> Encoding)
-> ([Hits_] -> Value)
-> ([Hits_] -> Encoding)
-> (Hits_ -> Bool)
-> ToJSON Hits_
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Hits_ -> Value
toJSON :: Hits_ -> Value
$ctoEncoding :: Hits_ -> Encoding
toEncoding :: Hits_ -> Encoding
$ctoJSONList :: [Hits_] -> Value
toJSONList :: [Hits_] -> Value
$ctoEncodingList :: [Hits_] -> Encoding
toEncodingList :: [Hits_] -> Encoding
$comitField :: Hits_ -> Bool
omitField :: Hits_ -> Bool
ToJSON)

-- | Match for a vector
data Match = Match
    { Match -> Text
id :: Text
    , Match -> Maybe Double
score :: Maybe Double
    , Match -> Maybe (Vector Double)
values :: Maybe (Vector Double)
    , Match -> Maybe SparseValues
sparseValues :: Maybe SparseValues
    , Match -> Maybe (Map Text Scalar)
metadata :: Maybe (Map Text Scalar)
    } deriving stock (Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
/= :: Match -> Match -> Bool
Eq, (forall x. Match -> Rep Match x)
-> (forall x. Rep Match x -> Match) -> Generic Match
forall x. Rep Match x -> Match
forall x. Match -> Rep Match x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Match -> Rep Match x
from :: forall x. Match -> Rep Match x
$cto :: forall x. Rep Match x -> Match
to :: forall x. Rep Match x -> Match
Generic, Int -> Match -> ShowS
[Match] -> ShowS
Match -> String
(Int -> Match -> ShowS)
-> (Match -> String) -> ([Match] -> ShowS) -> Show Match
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Match -> ShowS
showsPrec :: Int -> Match -> ShowS
$cshow :: Match -> String
show :: Match -> String
$cshowList :: [Match] -> ShowS
showList :: [Match] -> ShowS
Show)
      deriving anyclass (Maybe Match
Value -> Parser [Match]
Value -> Parser Match
(Value -> Parser Match)
-> (Value -> Parser [Match]) -> Maybe Match -> FromJSON Match
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Match
parseJSON :: Value -> Parser Match
$cparseJSONList :: Value -> Parser [Match]
parseJSONList :: Value -> Parser [Match]
$comittedField :: Maybe Match
omittedField :: Maybe Match
FromJSON, [Match] -> Value
[Match] -> Encoding
Match -> Bool
Match -> Value
Match -> Encoding
(Match -> Value)
-> (Match -> Encoding)
-> ([Match] -> Value)
-> ([Match] -> Encoding)
-> (Match -> Bool)
-> ToJSON Match
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Match -> Value
toJSON :: Match -> Value
$ctoEncoding :: Match -> Encoding
toEncoding :: Match -> Encoding
$ctoJSONList :: [Match] -> Value
toJSONList :: [Match] -> Value
$ctoEncodingList :: [Match] -> Encoding
toEncodingList :: [Match] -> Encoding
$comitField :: Match -> Bool
omitField :: Match -> Bool
ToJSON)

-- | The query inputs to search with
data Query = Query
    { Query -> Natural
top_k :: Natural
    , Query -> Maybe Filter
filter :: Maybe Filter
    , Query -> Maybe Text
input :: Maybe Text
    , Query -> Maybe VectorQuery
vector :: Maybe VectorQuery
    } deriving stock (Query -> Query -> Bool
(Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
/= :: Query -> Query -> Bool
Eq, (forall x. Query -> Rep Query x)
-> (forall x. Rep Query x -> Query) -> Generic Query
forall x. Rep Query x -> Query
forall x. Query -> Rep Query x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Query -> Rep Query x
from :: forall x. Query -> Rep Query x
$cto :: forall x. Rep Query x -> Query
to :: forall x. Rep Query x -> Query
Generic, Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
(Int -> Query -> ShowS)
-> (Query -> String) -> ([Query] -> ShowS) -> Show Query
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Query -> ShowS
showsPrec :: Int -> Query -> ShowS
$cshow :: Query -> String
show :: Query -> String
$cshowList :: [Query] -> ShowS
showList :: [Query] -> ShowS
Show)

data Query_ = Query_
    { Query_ -> Natural
top_k :: Natural
    , Query_ -> Maybe Filter
filter :: Maybe Filter
    , Query_ -> Maybe Input
inputs :: Maybe Input
    , Query_ -> Maybe VectorQuery
vector :: Maybe VectorQuery
    } deriving stock (Query_ -> Query_ -> Bool
(Query_ -> Query_ -> Bool)
-> (Query_ -> Query_ -> Bool) -> Eq Query_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Query_ -> Query_ -> Bool
== :: Query_ -> Query_ -> Bool
$c/= :: Query_ -> Query_ -> Bool
/= :: Query_ -> Query_ -> Bool
Eq, (forall x. Query_ -> Rep Query_ x)
-> (forall x. Rep Query_ x -> Query_) -> Generic Query_
forall x. Rep Query_ x -> Query_
forall x. Query_ -> Rep Query_ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Query_ -> Rep Query_ x
from :: forall x. Query_ -> Rep Query_ x
$cto :: forall x. Rep Query_ x -> Query_
to :: forall x. Rep Query_ x -> Query_
Generic, Int -> Query_ -> ShowS
[Query_] -> ShowS
Query_ -> String
(Int -> Query_ -> ShowS)
-> (Query_ -> String) -> ([Query_] -> ShowS) -> Show Query_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Query_ -> ShowS
showsPrec :: Int -> Query_ -> ShowS
$cshow :: Query_ -> String
show :: Query_ -> String
$cshowList :: [Query_] -> ShowS
showList :: [Query_] -> ShowS
Show)
      deriving anyclass (Maybe Query_
Value -> Parser [Query_]
Value -> Parser Query_
(Value -> Parser Query_)
-> (Value -> Parser [Query_]) -> Maybe Query_ -> FromJSON Query_
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Query_
parseJSON :: Value -> Parser Query_
$cparseJSONList :: Value -> Parser [Query_]
parseJSONList :: Value -> Parser [Query_]
$comittedField :: Maybe Query_
omittedField :: Maybe Query_
FromJSON, [Query_] -> Value
[Query_] -> Encoding
Query_ -> Bool
Query_ -> Value
Query_ -> Encoding
(Query_ -> Value)
-> (Query_ -> Encoding)
-> ([Query_] -> Value)
-> ([Query_] -> Encoding)
-> (Query_ -> Bool)
-> ToJSON Query_
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Query_ -> Value
toJSON :: Query_ -> Value
$ctoEncoding :: Query_ -> Encoding
toEncoding :: Query_ -> Encoding
$ctoJSONList :: [Query_] -> Value
toJSONList :: [Query_] -> Value
$ctoEncodingList :: [Query_] -> Encoding
toEncodingList :: [Query_] -> Encoding
$comitField :: Query_ -> Bool
omitField :: Query_ -> Bool
ToJSON)

instance FromJSON Query where
    parseJSON :: Value -> Parser Query
parseJSON Value
value = do
        Query_{Natural
Maybe Filter
Maybe Input
Maybe VectorQuery
$sel:top_k:Query_ :: Query_ -> Natural
$sel:filter:Query_ :: Query_ -> Maybe Filter
$sel:inputs:Query_ :: Query_ -> Maybe Input
$sel:vector:Query_ :: Query_ -> Maybe VectorQuery
top_k :: Natural
filter :: Maybe Filter
inputs :: Maybe Input
vector :: Maybe VectorQuery
..} <- Value -> Parser Query_
forall a. FromJSON a => Value -> Parser a
parseJSON Value
value

        let input :: Maybe Text
input = do
                Input{Text
text :: Text
$sel:text:Input :: Input -> Text
..} <- Maybe Input
inputs
                Text -> Maybe Text
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
text

        Query -> Parser Query
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return Query{Natural
Maybe Text
Maybe Filter
Maybe VectorQuery
$sel:top_k:Query :: Natural
$sel:filter:Query :: Maybe Filter
$sel:input:Query :: Maybe Text
$sel:vector:Query :: Maybe VectorQuery
top_k :: Natural
filter :: Maybe Filter
vector :: Maybe VectorQuery
input :: Maybe Text
..}

instance ToJSON Query where
    toJSON :: Query -> Value
toJSON Query{Natural
Maybe Text
Maybe Filter
Maybe VectorQuery
$sel:top_k:Query :: Query -> Natural
$sel:filter:Query :: Query -> Maybe Filter
$sel:input:Query :: Query -> Maybe Text
$sel:vector:Query :: Query -> Maybe VectorQuery
top_k :: Natural
filter :: Maybe Filter
input :: Maybe Text
vector :: Maybe VectorQuery
..} = Query_ -> Value
forall a. ToJSON a => a -> Value
toJSON Query_{Natural
Maybe Filter
Maybe Input
Maybe VectorQuery
$sel:top_k:Query_ :: Natural
$sel:filter:Query_ :: Maybe Filter
$sel:inputs:Query_ :: Maybe Input
$sel:vector:Query_ :: Maybe VectorQuery
top_k :: Natural
filter :: Maybe Filter
vector :: Maybe VectorQuery
inputs :: Maybe Input
..}
      where
        inputs :: Maybe Input
inputs = do
            Text
text <- Maybe Text
input

            Input -> Maybe Input
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return Input{Text
$sel:text:Input :: Text
text :: Text
..}

-- | Default `Query`
_Query :: Query
_Query :: Query
_Query = Query
    { $sel:filter:Query :: Maybe Filter
filter = Maybe Filter
forall a. Maybe a
Nothing
    , $sel:input:Query :: Maybe Text
input = Maybe Text
forall a. Maybe a
Nothing
    , $sel:vector:Query :: Maybe VectorQuery
vector = Maybe VectorQuery
forall a. Maybe a
Nothing
    }

-- | Vector query
data VectorQuery = VectorQuery
    { VectorQuery -> Maybe (Vector Double)
values :: Maybe (Vector Double)
    , VectorQuery -> Maybe (Vector Double)
sparse_values :: Maybe (Vector Double)
    , VectorQuery -> Maybe (Vector Natural)
sparse_indices :: Maybe (Vector Natural)
    } deriving stock (VectorQuery -> VectorQuery -> Bool
(VectorQuery -> VectorQuery -> Bool)
-> (VectorQuery -> VectorQuery -> Bool) -> Eq VectorQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VectorQuery -> VectorQuery -> Bool
== :: VectorQuery -> VectorQuery -> Bool
$c/= :: VectorQuery -> VectorQuery -> Bool
/= :: VectorQuery -> VectorQuery -> Bool
Eq, (forall x. VectorQuery -> Rep VectorQuery x)
-> (forall x. Rep VectorQuery x -> VectorQuery)
-> Generic VectorQuery
forall x. Rep VectorQuery x -> VectorQuery
forall x. VectorQuery -> Rep VectorQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VectorQuery -> Rep VectorQuery x
from :: forall x. VectorQuery -> Rep VectorQuery x
$cto :: forall x. Rep VectorQuery x -> VectorQuery
to :: forall x. Rep VectorQuery x -> VectorQuery
Generic, Int -> VectorQuery -> ShowS
[VectorQuery] -> ShowS
VectorQuery -> String
(Int -> VectorQuery -> ShowS)
-> (VectorQuery -> String)
-> ([VectorQuery] -> ShowS)
-> Show VectorQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VectorQuery -> ShowS
showsPrec :: Int -> VectorQuery -> ShowS
$cshow :: VectorQuery -> String
show :: VectorQuery -> String
$cshowList :: [VectorQuery] -> ShowS
showList :: [VectorQuery] -> ShowS
Show)
      deriving anyclass (Maybe VectorQuery
Value -> Parser [VectorQuery]
Value -> Parser VectorQuery
(Value -> Parser VectorQuery)
-> (Value -> Parser [VectorQuery])
-> Maybe VectorQuery
-> FromJSON VectorQuery
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser VectorQuery
parseJSON :: Value -> Parser VectorQuery
$cparseJSONList :: Value -> Parser [VectorQuery]
parseJSONList :: Value -> Parser [VectorQuery]
$comittedField :: Maybe VectorQuery
omittedField :: Maybe VectorQuery
FromJSON, [VectorQuery] -> Value
[VectorQuery] -> Encoding
VectorQuery -> Bool
VectorQuery -> Value
VectorQuery -> Encoding
(VectorQuery -> Value)
-> (VectorQuery -> Encoding)
-> ([VectorQuery] -> Value)
-> ([VectorQuery] -> Encoding)
-> (VectorQuery -> Bool)
-> ToJSON VectorQuery
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: VectorQuery -> Value
toJSON :: VectorQuery -> Value
$ctoEncoding :: VectorQuery -> Encoding
toEncoding :: VectorQuery -> Encoding
$ctoJSONList :: [VectorQuery] -> Value
toJSONList :: [VectorQuery] -> Value
$ctoEncodingList :: [VectorQuery] -> Encoding
toEncodingList :: [VectorQuery] -> Encoding
$comitField :: VectorQuery -> Bool
omitField :: VectorQuery -> Bool
ToJSON)

-- | Parameters for reranking the initial search results
data Rerank = Rerank
    { Rerank -> Text
model :: Text
    , Rerank -> Vector Text
rank_fields :: Vector Text
    , Rerank -> Maybe Natural
top_n :: Maybe Natural
    , Rerank -> Maybe (Map Text Value)
parameters :: Maybe (Map Text Value)
    , Rerank -> Maybe Text
query :: Maybe Text
    } deriving stock (Rerank -> Rerank -> Bool
(Rerank -> Rerank -> Bool)
-> (Rerank -> Rerank -> Bool) -> Eq Rerank
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rerank -> Rerank -> Bool
== :: Rerank -> Rerank -> Bool
$c/= :: Rerank -> Rerank -> Bool
/= :: Rerank -> Rerank -> Bool
Eq, (forall x. Rerank -> Rep Rerank x)
-> (forall x. Rep Rerank x -> Rerank) -> Generic Rerank
forall x. Rep Rerank x -> Rerank
forall x. Rerank -> Rep Rerank x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Rerank -> Rep Rerank x
from :: forall x. Rerank -> Rep Rerank x
$cto :: forall x. Rep Rerank x -> Rerank
to :: forall x. Rep Rerank x -> Rerank
Generic, Int -> Rerank -> ShowS
[Rerank] -> ShowS
Rerank -> String
(Int -> Rerank -> ShowS)
-> (Rerank -> String) -> ([Rerank] -> ShowS) -> Show Rerank
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Rerank -> ShowS
showsPrec :: Int -> Rerank -> ShowS
$cshow :: Rerank -> String
show :: Rerank -> String
$cshowList :: [Rerank] -> ShowS
showList :: [Rerank] -> ShowS
Show)
      deriving anyclass (Maybe Rerank
Value -> Parser [Rerank]
Value -> Parser Rerank
(Value -> Parser Rerank)
-> (Value -> Parser [Rerank]) -> Maybe Rerank -> FromJSON Rerank
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Rerank
parseJSON :: Value -> Parser Rerank
$cparseJSONList :: Value -> Parser [Rerank]
parseJSONList :: Value -> Parser [Rerank]
$comittedField :: Maybe Rerank
omittedField :: Maybe Rerank
FromJSON, [Rerank] -> Value
[Rerank] -> Encoding
Rerank -> Bool
Rerank -> Value
Rerank -> Encoding
(Rerank -> Value)
-> (Rerank -> Encoding)
-> ([Rerank] -> Value)
-> ([Rerank] -> Encoding)
-> (Rerank -> Bool)
-> ToJSON Rerank
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Rerank -> Value
toJSON :: Rerank -> Value
$ctoEncoding :: Rerank -> Encoding
toEncoding :: Rerank -> Encoding
$ctoJSONList :: [Rerank] -> Value
toJSONList :: [Rerank] -> Value
$ctoEncodingList :: [Rerank] -> Encoding
toEncodingList :: [Rerank] -> Encoding
$comitField :: Rerank -> Bool
omitField :: Rerank -> Bool
ToJSON)

-- | Search result
data Result = Result
    { Result -> Vector Hit
hits :: Vector Hit
    } deriving stock (Result -> Result -> Bool
(Result -> Result -> Bool)
-> (Result -> Result -> Bool) -> Eq Result
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Result -> Result -> Bool
== :: Result -> Result -> Bool
$c/= :: Result -> Result -> Bool
/= :: Result -> Result -> Bool
Eq, (forall x. Result -> Rep Result x)
-> (forall x. Rep Result x -> Result) -> Generic Result
forall x. Rep Result x -> Result
forall x. Result -> Rep Result x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Result -> Rep Result x
from :: forall x. Result -> Rep Result x
$cto :: forall x. Rep Result x -> Result
to :: forall x. Rep Result x -> Result
Generic, Int -> Result -> ShowS
[Result] -> ShowS
Result -> String
(Int -> Result -> ShowS)
-> (Result -> String) -> ([Result] -> ShowS) -> Show Result
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Result -> ShowS
showsPrec :: Int -> Result -> ShowS
$cshow :: Result -> String
show :: Result -> String
$cshowList :: [Result] -> ShowS
showList :: [Result] -> ShowS
Show)
      deriving anyclass (Maybe Result
Value -> Parser [Result]
Value -> Parser Result
(Value -> Parser Result)
-> (Value -> Parser [Result]) -> Maybe Result -> FromJSON Result
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Result
parseJSON :: Value -> Parser Result
$cparseJSONList :: Value -> Parser [Result]
parseJSONList :: Value -> Parser [Result]
$comittedField :: Maybe Result
omittedField :: Maybe Result
FromJSON, [Result] -> Value
[Result] -> Encoding
Result -> Bool
Result -> Value
Result -> Encoding
(Result -> Value)
-> (Result -> Encoding)
-> ([Result] -> Value)
-> ([Result] -> Encoding)
-> (Result -> Bool)
-> ToJSON Result
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Result -> Value
toJSON :: Result -> Value
$ctoEncoding :: Result -> Encoding
toEncoding :: Result -> Encoding
$ctoJSONList :: [Result] -> Value
toJSONList :: [Result] -> Value
$ctoEncodingList :: [Result] -> Encoding
toEncodingList :: [Result] -> Encoding
$comitField :: Result -> Bool
omitField :: Result -> Bool
ToJSON)

-- | Hit for the search document request
data Hit = Hit
    { Hit -> Text
_id :: Text
    , Hit -> Double
_score :: Double
    , Hit -> Value
fields :: Value
    } deriving stock (Hit -> Hit -> Bool
(Hit -> Hit -> Bool) -> (Hit -> Hit -> Bool) -> Eq Hit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Hit -> Hit -> Bool
== :: Hit -> Hit -> Bool
$c/= :: Hit -> Hit -> Bool
/= :: Hit -> Hit -> Bool
Eq, (forall x. Hit -> Rep Hit x)
-> (forall x. Rep Hit x -> Hit) -> Generic Hit
forall x. Rep Hit x -> Hit
forall x. Hit -> Rep Hit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Hit -> Rep Hit x
from :: forall x. Hit -> Rep Hit x
$cto :: forall x. Rep Hit x -> Hit
to :: forall x. Rep Hit x -> Hit
Generic, Int -> Hit -> ShowS
[Hit] -> ShowS
Hit -> String
(Int -> Hit -> ShowS)
-> (Hit -> String) -> ([Hit] -> ShowS) -> Show Hit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Hit -> ShowS
showsPrec :: Int -> Hit -> ShowS
$cshow :: Hit -> String
show :: Hit -> String
$cshowList :: [Hit] -> ShowS
showList :: [Hit] -> ShowS
Show)
      deriving anyclass (Maybe Hit
Value -> Parser [Hit]
Value -> Parser Hit
(Value -> Parser Hit)
-> (Value -> Parser [Hit]) -> Maybe Hit -> FromJSON Hit
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Hit
parseJSON :: Value -> Parser Hit
$cparseJSONList :: Value -> Parser [Hit]
parseJSONList :: Value -> Parser [Hit]
$comittedField :: Maybe Hit
omittedField :: Maybe Hit
FromJSON, [Hit] -> Value
[Hit] -> Encoding
Hit -> Bool
Hit -> Value
Hit -> Encoding
(Hit -> Value)
-> (Hit -> Encoding)
-> ([Hit] -> Value)
-> ([Hit] -> Encoding)
-> (Hit -> Bool)
-> ToJSON Hit
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Hit -> Value
toJSON :: Hit -> Value
$ctoEncoding :: Hit -> Encoding
toEncoding :: Hit -> Encoding
$ctoJSONList :: [Hit] -> Value
toJSONList :: [Hit] -> Value
$ctoEncodingList :: [Hit] -> Encoding
toEncodingList :: [Hit] -> Encoding
$comitField :: Hit -> Bool
omitField :: Hit -> Bool
ToJSON)

-- | Usage
data Usage = Usage
    { Usage -> Maybe Natural
read_units :: Maybe Natural
    , Usage -> Maybe Natural
embed_total_tokens :: Maybe Natural
    , Usage -> Maybe Natural
rerank_units :: Maybe Natural
    } deriving stock (Usage -> Usage -> Bool
(Usage -> Usage -> Bool) -> (Usage -> Usage -> Bool) -> Eq Usage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Usage -> Usage -> Bool
== :: Usage -> Usage -> Bool
$c/= :: Usage -> Usage -> Bool
/= :: Usage -> Usage -> Bool
Eq, (forall x. Usage -> Rep Usage x)
-> (forall x. Rep Usage x -> Usage) -> Generic Usage
forall x. Rep Usage x -> Usage
forall x. Usage -> Rep Usage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Usage -> Rep Usage x
from :: forall x. Usage -> Rep Usage x
$cto :: forall x. Rep Usage x -> Usage
to :: forall x. Rep Usage x -> Usage
Generic, Int -> Usage -> ShowS
[Usage] -> ShowS
Usage -> String
(Int -> Usage -> ShowS)
-> (Usage -> String) -> ([Usage] -> ShowS) -> Show Usage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Usage -> ShowS
showsPrec :: Int -> Usage -> ShowS
$cshow :: Usage -> String
show :: Usage -> String
$cshowList :: [Usage] -> ShowS
showList :: [Usage] -> ShowS
Show)
      deriving anyclass (Maybe Usage
Value -> Parser [Usage]
Value -> Parser Usage
(Value -> Parser Usage)
-> (Value -> Parser [Usage]) -> Maybe Usage -> FromJSON Usage
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Usage
parseJSON :: Value -> Parser Usage
$cparseJSONList :: Value -> Parser [Usage]
parseJSONList :: Value -> Parser [Usage]
$comittedField :: Maybe Usage
omittedField :: Maybe Usage
FromJSON, [Usage] -> Value
[Usage] -> Encoding
Usage -> Bool
Usage -> Value
Usage -> Encoding
(Usage -> Value)
-> (Usage -> Encoding)
-> ([Usage] -> Value)
-> ([Usage] -> Encoding)
-> (Usage -> Bool)
-> ToJSON Usage
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Usage -> Value
toJSON :: Usage -> Value
$ctoEncoding :: Usage -> Encoding
toEncoding :: Usage -> Encoding
$ctoJSONList :: [Usage] -> Value
toJSONList :: [Usage] -> Value
$ctoEncodingList :: [Usage] -> Encoding
toEncodingList :: [Usage] -> Encoding
$comitField :: Usage -> Bool
omitField :: Usage -> Bool
ToJSON)

-- | Servant API
type API =
          (   "query"
          :>  ReqBody '[JSON] SearchWithVector
          :>  Post '[JSON] Matches
          )
    :<|>  (   "records"
          :>  "namespaces"
          :>  Capture "namespace" Namespace
          :>  "search"
          :>  ReqBody '[JSON] SearchWithText
          :>  Post '[JSON] Hits
          )