mirror of
https://github.com/infiniflow/ragflow.git
synced 2026-05-26 02:37:21 +08:00
bd4ce39038
## What - Add Perplexity as a chat and embedding provider backed by its OpenAI-compatible `/chat/completions` and `/v1/embeddings` APIs - Register Perplexity in the Go model factory and provider config - Support non-streaming chat, SSE streaming chat, embeddings, model listing, and connection checks Refs #14736 --------- Co-authored-by: Jin Hai <haijin.chn@gmail.com>
523 lines
16 KiB
Go
523 lines
16 KiB
Go
//
|
|
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
package models
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type PerplexityModel struct {
|
|
BaseURL map[string]string
|
|
URLSuffix URLSuffix
|
|
httpClient *http.Client
|
|
}
|
|
|
|
func NewPerplexityModel(baseURL map[string]string, urlSuffix URLSuffix) *PerplexityModel {
|
|
transport := http.DefaultTransport.(*http.Transport).Clone()
|
|
transport.MaxIdleConns = 100
|
|
transport.MaxIdleConnsPerHost = 10
|
|
transport.IdleConnTimeout = 90 * time.Second
|
|
transport.DisableCompression = false
|
|
transport.ResponseHeaderTimeout = 60 * time.Second
|
|
|
|
return &PerplexityModel{
|
|
BaseURL: baseURL,
|
|
URLSuffix: urlSuffix,
|
|
httpClient: &http.Client{
|
|
Transport: transport,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (p *PerplexityModel) NewInstance(baseURL map[string]string) ModelDriver {
|
|
return NewPerplexityModel(baseURL, p.URLSuffix)
|
|
}
|
|
|
|
func (p *PerplexityModel) Name() string {
|
|
return "perplexity"
|
|
}
|
|
|
|
func (p *PerplexityModel) baseURLForRegion(region string) (string, error) {
|
|
base, ok := p.BaseURL[region]
|
|
if !ok || base == "" {
|
|
return "", fmt.Errorf("perplexity: no base URL configured for region %q", region)
|
|
}
|
|
return strings.TrimSuffix(base, "/"), nil
|
|
}
|
|
|
|
func (p *PerplexityModel) chatPayload(modelName string, messages []Message, stream bool, chatModelConfig *ChatConfig) map[string]interface{} {
|
|
apiMessages := make([]map[string]interface{}, len(messages))
|
|
for i, msg := range messages {
|
|
apiMessages[i] = map[string]interface{}{
|
|
"role": msg.Role,
|
|
"content": msg.Content,
|
|
}
|
|
}
|
|
|
|
reqBody := map[string]interface{}{
|
|
"model": modelName,
|
|
"messages": apiMessages,
|
|
"stream": stream,
|
|
}
|
|
|
|
if chatModelConfig != nil {
|
|
if chatModelConfig.MaxTokens != nil {
|
|
reqBody["max_tokens"] = *chatModelConfig.MaxTokens
|
|
}
|
|
if chatModelConfig.Temperature != nil {
|
|
reqBody["temperature"] = *chatModelConfig.Temperature
|
|
}
|
|
if chatModelConfig.TopP != nil {
|
|
reqBody["top_p"] = *chatModelConfig.TopP
|
|
}
|
|
if chatModelConfig.Stop != nil {
|
|
reqBody["stop"] = *chatModelConfig.Stop
|
|
}
|
|
// Perplexity sonar-reasoning* models accept reasoning_effort.
|
|
if chatModelConfig.Effort != nil && strings.Contains(strings.ToLower(modelName), "reasoning") {
|
|
reqBody["reasoning_effort"] = *chatModelConfig.Effort
|
|
}
|
|
}
|
|
|
|
return reqBody
|
|
}
|
|
|
|
func (p *PerplexityModel) chatURL(apiConfig *APIConfig) (string, error) {
|
|
region := "default"
|
|
if apiConfig != nil && apiConfig.Region != nil && *apiConfig.Region != "" {
|
|
region = *apiConfig.Region
|
|
}
|
|
|
|
baseURL, err := p.baseURLForRegion(region)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("%s/%s", baseURL, p.URLSuffix.Chat), nil
|
|
}
|
|
|
|
type perplexityChatMessage struct {
|
|
Content string `json:"content"`
|
|
ReasoningContent string `json:"reasoning_content"`
|
|
Reasoning string `json:"reasoning"`
|
|
}
|
|
|
|
type perplexityChatChoice struct {
|
|
Message perplexityChatMessage `json:"message"`
|
|
Delta perplexityChatMessage `json:"delta"`
|
|
FinishReason string `json:"finish_reason"`
|
|
}
|
|
|
|
type perplexityChatResponse struct {
|
|
Choices []perplexityChatChoice `json:"choices"`
|
|
Error interface{} `json:"error"`
|
|
FinishReason string `json:"finish_reason"`
|
|
}
|
|
|
|
func (p *PerplexityModel) ChatWithMessages(modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig) (*ChatResponse, error) {
|
|
if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
|
|
return nil, fmt.Errorf("api key is required")
|
|
}
|
|
if strings.TrimSpace(modelName) == "" {
|
|
return nil, fmt.Errorf("model name is required")
|
|
}
|
|
if len(messages) == 0 {
|
|
return nil, fmt.Errorf("messages is empty")
|
|
}
|
|
|
|
url, err := p.chatURL(apiConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
jsonData, err := json.Marshal(p.chatPayload(modelName, messages, false, chatModelConfig))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), nonStreamCallTimeout)
|
|
defer cancel()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
|
|
|
|
resp, err := p.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to send request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response: %w", err)
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
var result perplexityChatResponse
|
|
if err = json.Unmarshal(body, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
if result.Error != nil {
|
|
return nil, fmt.Errorf("perplexity: upstream error: %v", result.Error)
|
|
}
|
|
if len(result.Choices) == 0 {
|
|
return nil, fmt.Errorf("no choices in response")
|
|
}
|
|
|
|
content := result.Choices[0].Message.Content
|
|
reasonContent := result.Choices[0].Message.ReasoningContent
|
|
if reasonContent == "" {
|
|
reasonContent = result.Choices[0].Message.Reasoning
|
|
}
|
|
return &ChatResponse{
|
|
Answer: &content,
|
|
ReasonContent: &reasonContent,
|
|
}, nil
|
|
}
|
|
|
|
const perplexityStreamTimeout = 10 * time.Minute
|
|
|
|
func (p *PerplexityModel) ChatStreamlyWithSender(modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, sender func(*string, *string) error) error {
|
|
if sender == nil {
|
|
return fmt.Errorf("sender is required")
|
|
}
|
|
if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
|
|
return fmt.Errorf("api key is required")
|
|
}
|
|
if strings.TrimSpace(modelName) == "" {
|
|
return fmt.Errorf("model name is required")
|
|
}
|
|
if len(messages) == 0 {
|
|
return fmt.Errorf("messages is empty")
|
|
}
|
|
if chatModelConfig != nil && chatModelConfig.Stream != nil && !*chatModelConfig.Stream {
|
|
return fmt.Errorf("stream must be true in ChatStreamlyWithSender")
|
|
}
|
|
|
|
url, err := p.chatURL(apiConfig)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
jsonData, err := json.Marshal(p.chatPayload(modelName, messages, true, chatModelConfig))
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
// ResponseHeaderTimeout caps the initial header wait. This context
|
|
// also caps the body-read phase so a stalled SSE stream cannot hold
|
|
// the caller's goroutine and connection indefinitely.
|
|
ctx, cancel := context.WithTimeout(context.Background(), perplexityStreamTimeout)
|
|
defer cancel()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
|
|
req.Header.Set("Accept", "text/event-stream")
|
|
|
|
resp, err := p.httpClient.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to send request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
scanner := bufio.NewScanner(resp.Body)
|
|
scanner.Buffer(make([]byte, 64*1024), 1024*1024)
|
|
sawTerminal := false
|
|
for scanner.Scan() {
|
|
line := scanner.Text()
|
|
if !strings.HasPrefix(line, "data:") {
|
|
continue
|
|
}
|
|
|
|
data := strings.TrimSpace(line[5:])
|
|
if data == "[DONE]" {
|
|
sawTerminal = true
|
|
break
|
|
}
|
|
|
|
var event perplexityChatResponse
|
|
if err = json.Unmarshal([]byte(data), &event); err != nil {
|
|
return fmt.Errorf("perplexity: invalid SSE event: %w", err)
|
|
}
|
|
if event.Error != nil {
|
|
return fmt.Errorf("perplexity: upstream stream error: %v", event.Error)
|
|
}
|
|
if len(event.Choices) == 0 {
|
|
continue
|
|
}
|
|
|
|
choice := event.Choices[0]
|
|
if choice.Delta.ReasoningContent != "" {
|
|
if err := sender(nil, &choice.Delta.ReasoningContent); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if choice.Delta.Reasoning != "" {
|
|
if err := sender(nil, &choice.Delta.Reasoning); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if choice.Delta.Content != "" {
|
|
if err := sender(&choice.Delta.Content, nil); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if choice.FinishReason != "" || event.FinishReason != "" {
|
|
sawTerminal = true
|
|
break
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
return fmt.Errorf("failed to scan response body: %w", err)
|
|
}
|
|
if !sawTerminal {
|
|
return fmt.Errorf("perplexity: stream ended before [DONE] or finish_reason")
|
|
}
|
|
|
|
endOfStream := "[DONE]"
|
|
return sender(&endOfStream, nil)
|
|
}
|
|
|
|
type perplexityModelInfo struct {
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
type perplexityModelListResponse struct {
|
|
Data []perplexityModelInfo `json:"data"`
|
|
}
|
|
|
|
func (p *PerplexityModel) ListModels(apiConfig *APIConfig) ([]string, error) {
|
|
if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
|
|
return nil, fmt.Errorf("api key is required")
|
|
}
|
|
|
|
region := "default"
|
|
if apiConfig.Region != nil && *apiConfig.Region != "" {
|
|
region = *apiConfig.Region
|
|
}
|
|
|
|
baseURL, err := p.baseURLForRegion(region)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
url := fmt.Sprintf("%s/%s", baseURL, p.URLSuffix.Models)
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), nonStreamCallTimeout)
|
|
defer cancel()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
|
|
|
|
resp, err := p.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to send request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response: %w", err)
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
// Perplexity returns OpenAI-style {"data": [{"id": "..."}]}. Older
|
|
// or alternate payloads may return a bare array; accept both.
|
|
var wrapped perplexityModelListResponse
|
|
if err = json.Unmarshal(body, &wrapped); err == nil && len(wrapped.Data) > 0 {
|
|
models := make([]string, 0, len(wrapped.Data))
|
|
for _, model := range wrapped.Data {
|
|
if model.ID != "" {
|
|
models = append(models, model.ID)
|
|
}
|
|
}
|
|
return models, nil
|
|
}
|
|
|
|
var bare []perplexityModelInfo
|
|
if err = json.Unmarshal(body, &bare); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
models := make([]string, 0, len(bare))
|
|
for _, model := range bare {
|
|
if model.ID != "" {
|
|
models = append(models, model.ID)
|
|
}
|
|
}
|
|
return models, nil
|
|
}
|
|
|
|
func (p *PerplexityModel) CheckConnection(apiConfig *APIConfig) error {
|
|
_, err := p.ListModels(apiConfig)
|
|
return err
|
|
}
|
|
|
|
type perplexityEmbeddingDataItem struct {
|
|
Embedding []float64 `json:"embedding"`
|
|
Index int `json:"index"`
|
|
Object string `json:"object"`
|
|
}
|
|
|
|
type perplexityEmbeddingResponse struct {
|
|
Data []perplexityEmbeddingDataItem `json:"data"`
|
|
Model string `json:"model"`
|
|
Error interface{} `json:"error"`
|
|
}
|
|
|
|
func (p *PerplexityModel) Embed(modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig) ([]EmbeddingData, error) {
|
|
if len(texts) == 0 {
|
|
return []EmbeddingData{}, nil
|
|
}
|
|
if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
|
|
return nil, fmt.Errorf("api key is required")
|
|
}
|
|
if modelName == nil || *modelName == "" {
|
|
return nil, fmt.Errorf("model name is required")
|
|
}
|
|
|
|
region := "default"
|
|
if apiConfig.Region != nil && *apiConfig.Region != "" {
|
|
region = *apiConfig.Region
|
|
}
|
|
|
|
baseURL, err := p.baseURLForRegion(region)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
url := fmt.Sprintf("%s/%s", baseURL, p.URLSuffix.Embedding)
|
|
|
|
reqBody := map[string]interface{}{
|
|
"model": *modelName,
|
|
"input": texts,
|
|
}
|
|
if embeddingConfig != nil && embeddingConfig.Dimension > 0 {
|
|
reqBody["dimensions"] = embeddingConfig.Dimension
|
|
}
|
|
|
|
jsonData, err := json.Marshal(reqBody)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), nonStreamCallTimeout)
|
|
defer cancel()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
|
|
|
|
resp, err := p.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to send request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response: %w", err)
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("perplexity embeddings API error: %s, body: %s", resp.Status, string(body))
|
|
}
|
|
|
|
var parsed perplexityEmbeddingResponse
|
|
if err = json.Unmarshal(body, &parsed); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
if parsed.Error != nil {
|
|
return nil, fmt.Errorf("perplexity: upstream error: %v", parsed.Error)
|
|
}
|
|
|
|
embeddings := make([]EmbeddingData, 0, len(parsed.Data))
|
|
for _, item := range parsed.Data {
|
|
embeddings = append(embeddings, EmbeddingData{
|
|
Embedding: item.Embedding,
|
|
Index: item.Index,
|
|
})
|
|
}
|
|
return embeddings, nil
|
|
}
|
|
|
|
func (p *PerplexityModel) Rerank(modelName *string, query string, documents []string, apiConfig *APIConfig, rerankConfig *RerankConfig) (*RerankResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) Balance(apiConfig *APIConfig) (map[string]interface{}, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) TranscribeAudio(modelName *string, file *string, apiConfig *APIConfig, asrConfig *ASRConfig) (*ASRResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) TranscribeAudioWithSender(modelName *string, file *string, apiConfig *APIConfig, asrConfig *ASRConfig, sender func(*string, *string) error) error {
|
|
return fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) AudioSpeech(modelName *string, audioContent *string, apiConfig *APIConfig, ttsConfig *TTSConfig) (*TTSResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) AudioSpeechWithSender(modelName *string, audioContent *string, apiConfig *APIConfig, ttsConfig *TTSConfig, sender func(*string, *string) error) error {
|
|
return fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) OCRFile(modelName *string, content []byte, url *string, apiConfig *APIConfig, ocrConfig *OCRConfig) (*OCRFileResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) ParseFile(modelName *string, content []byte, url *string, apiConfig *APIConfig, parseFileConfig *ParseFileConfig) (*ParseFileResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) ListTasks(apiConfig *APIConfig) ([]ListTaskStatus, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|
|
|
|
func (p *PerplexityModel) ShowTask(taskID string, apiConfig *APIConfig) (*TaskResponse, error) {
|
|
return nil, fmt.Errorf("%s, no such method", p.Name())
|
|
}
|