Conversation
📝 WalkthroughWalkthroughThe changes in this pull request primarily involve updates to the Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant DappierApp
participant API
User->>DappierApp: Search(query, dataModelID, opts)
DappierApp->>API: Send search request
API-->>DappierApp: Return search results
DappierApp-->>User: Provide search results
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 9
🧹 Outside diff range comments (5)
README.md (1)
Line range hint
1-218: Address markdown formatting issuesTo improve the overall consistency and readability of the document, please address the following markdown formatting issues:
- Replace hard tabs with spaces for consistent indentation (lines 32, 66, and potentially others).
- Remove extra blank lines to maintain a single blank line between sections (e.g., line 142).
- Ensure all headings are surrounded by blank lines for better readability.
- Remove trailing punctuation (colons) from headings in the Parameters section.
- Add blank lines before and after lists for better separation.
These changes will enhance the document's overall structure and adherence to common markdown best practices.
🧰 Tools
🪛 LanguageTool
[uncategorized] ~204-~204: A determiner appears to be missing. Consider inserting it.
Context: ...r): - The number of articles to return. Default is 9. ###ref(string): - The domain...(AI_EN_LECTOR_MISSING_DETERMINER)
[uncategorized] ~217-~217: Loose punctuation mark.
Context: ...o retrieve articles. -"most_recent": Retrieves articles sorted by the most r...(UNLIKELY_OPENING_PUNCTUATION)
🪛 Markdownlint
142-142: Expected: 1; Actual: 2
Multiple consecutive blank lines(MD012, no-multiple-blanks)
199-199: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
203-203: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
206-206: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
210-210: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
214-214: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
197-197: null
Multiple headings with the same content(MD024, no-duplicate-heading)
199-199: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
203-203: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
206-206: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
210-210: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
214-214: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
200-200: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
204-204: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
207-207: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
211-211: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
215-215: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
dappier.go (4)
Line range hint
209-223: Use Appropriate Request Struct inAIRecommendationsThe
AIRecommendationsmethod is currently usingSearchRequestas its payload, which might not accurately represent the required fields for AI recommendations. Define a dedicatedAiRecommendationsRequeststruct to ensure the request payload matches the API's expectations and to improve code clarity.Example:
type AiRecommendationsRequest struct { Query string `json:"query"` SimilarityTopK int `json:"similarity_top_k"` Ref string `json:"ref"` NumArticlesRef int `json:"num_articles_ref"` // Add any other fields specific to AI recommendations }Update the method to use this struct:
- requestData := SearchRequest{ + requestData := AiRecommendationsRequest{
Line range hint
209-223: Apply DRY Principle to Reduce Duplicate CodeThe
AIRecommendationsandSearchmethods contain duplicate code for setting up HTTP requests and handling responses. Refactor common functionality into helper methods to adhere to the DRY (Don't Repeat Yourself) principle, improving maintainability.Example:
- Create a helper function to handle HTTP request creation and response parsing.
- Parameters can include the URL, request payload, and expected response structure.
Also applies to: 301-366
Line range hint
14-366: Concurrency Considerations forDappierAppIf instances of
DappierAppare intended to be used concurrently across multiple goroutines, ensure that shared resources (like thehttp.Clientor any internal state) are safe for concurrent access.Consider documenting the concurrency guarantees or adding synchronization as needed.
Line range hint
209-223: Handle Non-OK HTTP Status Codes GracefullyIn the
AIRecommendationsmethod, when a non-OK HTTP status is received, only the status code is returned in the error. Consider including the response body or additional context to aid in debugging.Example:
if resp.StatusCode != http.StatusOK { + body, _ := io.ReadAll(resp.Body) return nil, fmt.Errorf("received non-OK response status: %d, body: %s", resp.StatusCode, body) }
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
📒 Files selected for processing (2)
- README.md (4 hunks)
- dappier.go (4 hunks)
🧰 Additional context used
📓 Path-based instructions (1)
dappier.go (1)
Pattern
**/*.go: Be sure that the code is optimized to enable concurrency, efficient use of threading and follows the standard go guide, always point out all possible unhandled error case and suggest code snippets to improve key areas such as:
- Logic
- Security
- Performance
- Data races
- Consistency
- Error handling
- Maintainability
- Modularity
- Complexity
- Optimization
- Best practices: DRY, SOLID, KISS
🪛 Markdownlint
README.md
32-32: Column: 1
Hard tabs(MD010, no-hard-tabs)
66-66: Column: 1
Hard tabs(MD010, no-hard-tabs)
142-142: Expected: 1; Actual: 2
Multiple consecutive blank lines(MD012, no-multiple-blanks)
199-199: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
203-203: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
206-206: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
210-210: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
214-214: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
197-197: null
Multiple headings with the same content(MD024, no-duplicate-heading)
199-199: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
203-203: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
206-206: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
210-210: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
214-214: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
200-200: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
204-204: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
207-207: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
211-211: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
215-215: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
🪛 LanguageTool
README.md
[uncategorized] ~204-~204: A determiner appears to be missing. Consider inserting it.
Context: ...r): - The number of articles to return. Default is 9. ###ref(string): - The domain...(AI_EN_LECTOR_MISSING_DETERMINER)
[uncategorized] ~217-~217: Loose punctuation mark.
Context: ...o retrieve articles. -"most_recent": Retrieves articles sorted by the most r...(UNLIKELY_OPENING_PUNCTUATION)
🔇 Additional comments (2)
README.md (1)
14-14: Verify consistency of import path changeThe package import path has been updated from
github.com/DappierAI/dappier-gotogithub.com/dappier/dappier-go. This change appears to be consistent across all code examples in the file. However, it's crucial to ensure this change is applied uniformly throughout the entire codebase and documentation.To confirm the consistency of this change, please run the following script:
If the script returns any results, those instances should be updated to the new import path.
Also applies to: 32-32, 66-66, 155-155
✅ Verification successful
Import path change is consistent
All instances of the old import path
github.com/DappierAI/dappier-gohave been successfully updated togithub.com/dappier/dappier-goacross documentation and source files. No remaining instances found.🏁 Scripts executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Check for any remaining instances of the old import path # Test: Search for any remaining instances of the old import path rg --type md "github.com/DappierAI/dappier-go"Length of output: 46
Script:
#!/bin/bash # Description: Corrected script to check for any remaining instances of the old import path in Markdown files # Test: Search for any remaining instances of the old import path in README.md and other Markdown files rg --type md "github.com/DappierAI/dappier-go"Length of output: 46
Script:
#!/bin/bash # Description: Search for any remaining instances of the old import path across all relevant file types # Test: Search for the old import path in source code and documentation files rg "github.com/DappierAI/dappier-go" --type py --type js --type go --type md --type txtLength of output: 87
dappier.go (1)
327-328:⚠️ Potential issueValidate URL Parameter Encoding
When constructing the URL for the search request, ensure that
dataModelIDis properly URL-encoded to handle any special characters.- url := fmt.Sprintf("%s?data_model_id=%s", SearchBaseUrl, dataModelID) + url := fmt.Sprintf("%s?data_model_id=%s", SearchBaseUrl, url.QueryEscape(dataModelID))Alternatively, use the
net/urlpackage to build query parameters.Would you like assistance in updating the URL construction?
| ## Search API Usage | ||
|
|
||
| The Search API allows you to query with different data_model_ids, enabling flexible data search across different models. | ||
|
|
||
| Here’s how to use the Search API: | ||
|
|
||
| ```go | ||
| package main | ||
|
|
||
| import ( | ||
| "fmt" | ||
| "log" | ||
| "github.com/dappier/dappier-go" | ||
| ) | ||
|
|
||
| func main() { | ||
| // Initialize Dappier client | ||
| client, err := dappier.NewDappierApp("your-api-key") | ||
| if err != nil { | ||
| log.Fatalf("Failed to initialize Dappier client: %v", err) | ||
| } | ||
|
|
||
| // Example: Search with default options | ||
| searchResult, err := client.Search("Latest Microsoft News", "dm_01htjq2njgecvah7ncepm8v87y") | ||
| if err != nil { | ||
| log.Fatalf("Failed to get search results: %v", err) | ||
| } | ||
|
|
||
| // Print the results | ||
| for _, result := range searchResult.Response.Results { | ||
| fmt.Printf("Search Result - %v\n", result) | ||
| } | ||
|
|
||
| // Example: Search with custom options | ||
| searchCustomResult, err := client.Search( | ||
| "Latest Microsoft News", | ||
| "dm_01htjq2njgecvah7ncepm8v87y", | ||
| dappier.WithSearchSimilarityTopK(6), // Custom similarity_top_k | ||
| dappier.WithSearchRef("familyproof.com"), // Custom ref | ||
| dappier.WithSearchNumArticlesRef(3), // Ensure 3 articles from the domain | ||
| ) | ||
| if err != nil { | ||
| log.Fatalf("Failed to get search results: %v", err) | ||
| } | ||
|
|
||
| // Print the custom results | ||
| for _, result := range searchCustomResult.Response.Results { | ||
| fmt.Printf("Search Result (Custom) - %v\n", result) | ||
| } | ||
| } | ||
|
|
||
|
|
||
| ``` |
There was a problem hiding this comment.
🧹 Nitpick (assertive)
Approve addition of Search API Usage section with minor suggestion
The new "Search API Usage" section is a valuable addition to the documentation. It provides clear explanations and code examples for both default and custom usage of the Search API. The structure and style are consistent with the existing "AI Recommendations API Usage" section, which is excellent for maintaining documentation coherence.
To further improve clarity, consider adding a brief explanation of the data_model_id parameter in the introductory paragraph or as a comment in the code example. This would help users understand the significance of this parameter when using the Search API.
| ```go | ||
| package main | ||
|
|
||
| import ( | ||
| "fmt" | ||
| "log" | ||
| "github.com/dappier/dappier-go" | ||
| ) | ||
|
|
||
| func main() { | ||
| // Initialize Dappier client | ||
| client, err := dappier.NewDappierApp("your-api-key") | ||
| if err != nil { | ||
| log.Fatalf("Failed to initialize Dappier client: %v", err) | ||
| } | ||
|
|
||
| // Example: Search with default options | ||
| searchResult, err := client.Search("Latest Microsoft News", "dm_01htjq2njgecvah7ncepm8v87y") | ||
| if err != nil { | ||
| log.Fatalf("Failed to get search results: %v", err) | ||
| } | ||
|
|
||
| // Print the results | ||
| for _, result := range searchResult.Response.Results { | ||
| fmt.Printf("Search Result - %v\n", result) | ||
| } | ||
|
|
||
| // Example: Search with custom options | ||
| searchCustomResult, err := client.Search( | ||
| "Latest Microsoft News", | ||
| "dm_01htjq2njgecvah7ncepm8v87y", | ||
| dappier.WithSearchSimilarityTopK(6), // Custom similarity_top_k | ||
| dappier.WithSearchRef("familyproof.com"), // Custom ref | ||
| dappier.WithSearchNumArticlesRef(3), // Ensure 3 articles from the domain | ||
| ) | ||
| if err != nil { | ||
| log.Fatalf("Failed to get search results: %v", err) | ||
| } | ||
|
|
||
| // Print the custom results | ||
| for _, result := range searchCustomResult.Response.Results { | ||
| fmt.Printf("Search Result (Custom) - %v\n", result) | ||
| } | ||
| } | ||
|
|
||
|
|
||
| ``` |
There was a problem hiding this comment.
🧹 Nitpick (assertive)
Approve code examples with suggestion for consistency
The code examples for the Search API Usage are clear, demonstrative, and follow good practices such as proper error handling. They effectively show how to use both default and custom options when making Search API requests.
For consistency with the AI Recommendations API example, consider adding a brief comment explaining each custom option in the Search API example. This would help users understand the purpose of each parameter more easily.
Example of suggested addition:
searchCustomResult, err := client.Search(
"Latest Microsoft News",
"dm_01htjq2njgecvah7ncepm8v87y",
dappier.WithSearchSimilarityTopK(6), // Set custom number of results to return
dappier.WithSearchRef("familyproof.com"), // Set custom reference domain
dappier.WithSearchNumArticlesRef(3), // Ensure 3 articles from the reference domain
)| ## Parameters | ||
|
|
||
| ### `query` (string): | ||
| - A natural language query or URL. | ||
| - If a URL is passed, the AI analyzes the page, creates a summary, and performs a semantic search query based on the content. | ||
|
|
||
| ### `similarity_top_k` (integer): | ||
| - The number of articles to return. Default is 9. | ||
|
|
||
| ### `ref` (string): | ||
| - The domain of the site from which the recommendations should come. | ||
| - Example: `techcrunch.com`. | ||
|
|
||
| ### `num_articles_ref` (integer): | ||
| - Specifies how many articles should be guaranteed to match the domain specified in `ref`. | ||
| - Use this to ensure a set number of articles from the desired domain appear in the results. | ||
|
|
||
| ### `search_algorithm` (string): | ||
| - Options: `"most_recent"` or `"semantic"`. | ||
| - `"semantic"` (default): Contextual matching of the query to retrieve articles. | ||
| - `"most_recent"`: Retrieves articles sorted by the most recent publication date. | ||
|
|
There was a problem hiding this comment.
🧹 Nitpick (assertive)
Improve formatting of Search API Parameters section
The Parameters section for the Search API provides clear and consistent descriptions with the AI Recommendations API section. However, to maintain visual consistency throughout the document, consider applying the following formatting improvements:
- Add a blank line before and after each parameter heading.
- Remove the colon (
:) from the end of each parameter heading. - Ensure consistent indentation for list items under each parameter.
Here's an example of the suggested formatting:
## Parameters
### `query` (string)
- A natural language query or URL.
- If a URL is passed, the AI analyzes the page, creates a summary, and performs a semantic search query based on the content.
### `similarity_top_k` (integer)
- The number of articles to return. Default is 9.
...🧰 Tools
🪛 LanguageTool
[uncategorized] ~204-~204: A determiner appears to be missing. Consider inserting it.
Context: ...r): - The number of articles to return. Default is 9. ###ref(string): - The domain...(AI_EN_LECTOR_MISSING_DETERMINER)
[uncategorized] ~217-~217: Loose punctuation mark.
Context: ...o retrieve articles. -"most_recent": Retrieves articles sorted by the most r...(UNLIKELY_OPENING_PUNCTUATION)
🪛 Markdownlint
199-199: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
203-203: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
206-206: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
210-210: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
214-214: Expected: 1; Actual: 0; Below
Headings should be surrounded by blank lines(MD022, blanks-around-headings)
197-197: null
Multiple headings with the same content(MD024, no-duplicate-heading)
199-199: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
203-203: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
206-206: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
210-210: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
214-214: Punctuation: ':'
Trailing punctuation in heading(MD026, no-trailing-punctuation)
200-200: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
204-204: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
207-207: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
211-211: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
215-215: null
Lists should be surrounded by blank lines(MD032, blanks-around-lists)
|
|
||
| const ( | ||
| BaseUrl = "https://api.dappier.com/app/datamodel" | ||
| SearchBaseUrl = "https://api.dappier.com/app/v2/search" |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Consistency in Constant Naming
Consider renaming SearchBaseUrl to SearchBaseURL to maintain consistent camel casing with BaseUrl and improve code readability.
| // SearchRequest represents the request payload structure for the Dappier AI recommendations API | ||
| type SearchRequest struct { | ||
| Query string `json:"query"` // Natural language query or URL | ||
| SimilarityTopK int `json:"similarity_top_k"` // The number of articles to return (default is 9) | ||
| Ref string `json:"ref"` // Domain from which to fetch recommendations (e.g., techcrunch.com) | ||
| NumArticlesRef int `json:"num_articles_ref"` // Guaranteed number of articles from the specified domain | ||
| } |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Clarify the Purpose of SearchRequest Struct
The SearchRequest struct is introduced for the search functionality. However, it's currently being used in both the Search and AIRecommendations methods. To enhance code clarity and maintainability, consider creating separate structs for each API endpoint if their payloads differ or if they serve different purposes.
| return func(req *SearchRequest) { | ||
| req.SimilarityTopK = k | ||
| } | ||
| } | ||
|
|
||
| // WithRef sets the ref option | ||
| // The domain of the site from which the recommendations should come. For example, techcrunch.com. | ||
| func WithRef(ref string) RecommendationsOption { | ||
| return func(req *AiRecommendationsRequest) { | ||
| return func(req *SearchRequest) { | ||
| req.Ref = ref | ||
| } | ||
| } | ||
|
|
||
| // WithNumArticlesRef sets the num_articles_ref option | ||
| // Specifies how many articles should be guaranteed to match the domain specified in ref. | ||
| func WithNumArticlesRef(num int) RecommendationsOption { | ||
| return func(req *AiRecommendationsRequest) { | ||
| return func(req *SearchRequest) { |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Unify Option Functions for Consistency
There are separate option functions for AIRecommendations (WithSimilarityTopK, WithRef, WithNumArticlesRef) and for Search (WithSearchSimilarityTopK, WithSearchRef, WithSearchNumArticlesRef). To improve usability, consider unifying these functions or clearly differentiating them.
Options:
- Prefix all option functions with
Withand the API name, e.g.,WithAIRecommendationsSimilarityTopK,WithSearchSimilarityTopK. - Alternatively, if the options are the same for both APIs, use a common set of option functions.
Also applies to: 280-298
| Status string `json:"status"` | ||
| Response SearchResult `json:"response"` | ||
| } | ||
|
|
||
| type SearchResult struct { | ||
| Query string `json:"query"` | ||
| Results []map[string]interface{} `json:"results"` // Dynamic JSON structure | ||
| Message string `json:"message"` | ||
| } |
There was a problem hiding this comment.
Define Concrete Types for Search Results
Using map[string]interface{} for Results in SearchResult can lead to type assertions and potential runtime errors. Define a concrete struct for the search results to improve type safety and make the code more maintainable.
Example:
type SearchResult struct {
Query string `json:"query"`
- Results []map[string]interface{} `json:"results"` // Dynamic JSON structure
+ Results []SearchItem `json:"results"`
Message string `json:"message"`
}
+type SearchItem struct {
+ Title string `json:"title"`
+ URL string `json:"url"`
+ Author string `json:"author"`
+ ImageURL string `json:"image_url"`
+ PreviewContent string `json:"preview_content"`
+ PubDate string `json:"pubdate"`
+ PubDateUnix int64 `json:"pubdate_unix"`
+ Score float64 `json:"score"`
+ Site string `json:"site"`
+ SiteDomain string `json:"site_domain"`
+ // Add other relevant fields
+}📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| Status string `json:"status"` | |
| Response SearchResult `json:"response"` | |
| } | |
| type SearchResult struct { | |
| Query string `json:"query"` | |
| Results []map[string]interface{} `json:"results"` // Dynamic JSON structure | |
| Message string `json:"message"` | |
| } | |
| Status string `json:"status"` | |
| Response SearchResult `json:"response"` | |
| } | |
| type SearchResult struct { | |
| Query string `json:"query"` | |
| Results []SearchItem `json:"results"` | |
| Message string `json:"message"` | |
| } | |
| type SearchItem struct { | |
| Title string `json:"title"` | |
| URL string `json:"url"` | |
| Author string `json:"author"` | |
| ImageURL string `json:"image_url"` | |
| PreviewContent string `json:"preview_content"` | |
| PubDate string `json:"pubdate"` | |
| PubDateUnix int64 `json:"pubdate_unix"` | |
| Score float64 `json:"score"` | |
| Site string `json:"site"` | |
| SiteDomain string `json:"site_domain"` | |
| // Add other relevant fields | |
| } |
| type RecommendationsOption func(*SearchRequest) | ||
|
|
||
| // WithSimilarityTopK sets the similarity_top_k option. The number of articles to return. Default is 9. | ||
| func WithSimilarityTopK(k int) RecommendationsOption { | ||
| return func(req *AiRecommendationsRequest) { | ||
| return func(req *SearchRequest) { | ||
| req.SimilarityTopK = k | ||
| } | ||
| } | ||
|
|
||
| // WithRef sets the ref option | ||
| // The domain of the site from which the recommendations should come. For example, techcrunch.com. | ||
| func WithRef(ref string) RecommendationsOption { | ||
| return func(req *AiRecommendationsRequest) { | ||
| return func(req *SearchRequest) { | ||
| req.Ref = ref | ||
| } | ||
| } | ||
|
|
||
| // WithNumArticlesRef sets the num_articles_ref option | ||
| // Specifies how many articles should be guaranteed to match the domain specified in ref. | ||
| func WithNumArticlesRef(num int) RecommendationsOption { | ||
| return func(req *AiRecommendationsRequest) { | ||
| return func(req *SearchRequest) { |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Inconsistent Naming of Option Types and Functions
The option type RecommendationsOption and its associated functions (WithSimilarityTopK, WithRef, WithNumArticlesRef) are intended for AIRecommendations but are modifying SearchRequest. Similarly, new option types and functions are introduced for Search. This can cause confusion.
Consider the following:
- Rename
RecommendationsOptiontoSearchOptionif it's modifyingSearchRequest. - Ensure that option functions are clearly associated with their respective request types.
Example:
-type RecommendationsOption func(*SearchRequest)
+type RecommendationsOption func(*AiRecommendationsRequest)And update the functions accordingly.
Committable suggestion was skipped due to low confidence.
| func (d *DappierApp) Search(query string, dataModelID string, opts ...SearchOption) (*SearchResponse, error) { | ||
| // Validate inputs | ||
| if query == "" || dataModelID == "" { | ||
| return nil, errors.New("query and data_model_id cannot be empty") | ||
| } | ||
|
|
||
| // Create the default request payload with the provided query | ||
| requestData := SearchRequest{ | ||
| Query: query, | ||
| SimilarityTopK: 9, // default value | ||
| Ref: "", // default value | ||
| NumArticlesRef: 0, // default value | ||
| } | ||
|
|
||
| // Apply all optional parameters to the request data | ||
| for _, opt := range opts { | ||
| opt(&requestData) | ||
| } | ||
|
|
||
| // Marshal the request data into JSON | ||
| reqBody, err := json.Marshal(requestData) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("failed to marshal request data: %w", err) | ||
| } | ||
|
|
||
| // Construct the request URL with the provided data model ID | ||
| url := fmt.Sprintf("%s?data_model_id=%s", SearchBaseUrl, dataModelID) | ||
|
|
||
| // Create a new HTTP request | ||
| req, err := http.NewRequest("POST", url, bytes.NewBuffer(reqBody)) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("failed to create new request: %w", err) | ||
| } | ||
|
|
||
| // Set necessary headers | ||
| req.Header.Set("Content-Type", ContentType) | ||
| req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", d.APIKey)) | ||
|
|
||
| // Use the client's HTTP client to make the request | ||
| resp, err := d.Client.Do(req) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("error making HTTP request: %w", err) | ||
| } | ||
| defer resp.Body.Close() | ||
|
|
||
| // Check for non-OK status code | ||
| if resp.StatusCode != http.StatusOK { | ||
| return nil, fmt.Errorf("received non-OK response status: %d", resp.StatusCode) | ||
| } | ||
|
|
||
| // Read the response body using io.ReadAll | ||
| body, err := io.ReadAll(resp.Body) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("failed to read response body: %w", err) | ||
| } | ||
|
|
||
| // Unmarshal the response body into the SearchResponse structure | ||
| var result SearchResponse | ||
| err = json.Unmarshal(body, &result) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("failed to unmarshal response: %w", err) | ||
| } | ||
|
|
||
| // Return the result | ||
| return &result, nil | ||
| } |
There was a problem hiding this comment.
Check for Empty Results in Search Response
After unmarshalling the response in the Search method, there's no check to verify whether Results contains data. If the API returns an empty Results array, it might be appropriate to notify the caller.
Apply this diff to handle empty results:
// Unmarshal the response body into the SearchResponse structure
var result SearchResponse
err = json.Unmarshal(body, &result)
if err != nil {
return nil, fmt.Errorf("failed to unmarshal response: %w", err)
}
+// Check if results are available
+if len(result.Response.Results) == 0 {
+ return nil, errors.New("no search results found")
+}
return &result, nil📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| func (d *DappierApp) Search(query string, dataModelID string, opts ...SearchOption) (*SearchResponse, error) { | |
| // Validate inputs | |
| if query == "" || dataModelID == "" { | |
| return nil, errors.New("query and data_model_id cannot be empty") | |
| } | |
| // Create the default request payload with the provided query | |
| requestData := SearchRequest{ | |
| Query: query, | |
| SimilarityTopK: 9, // default value | |
| Ref: "", // default value | |
| NumArticlesRef: 0, // default value | |
| } | |
| // Apply all optional parameters to the request data | |
| for _, opt := range opts { | |
| opt(&requestData) | |
| } | |
| // Marshal the request data into JSON | |
| reqBody, err := json.Marshal(requestData) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to marshal request data: %w", err) | |
| } | |
| // Construct the request URL with the provided data model ID | |
| url := fmt.Sprintf("%s?data_model_id=%s", SearchBaseUrl, dataModelID) | |
| // Create a new HTTP request | |
| req, err := http.NewRequest("POST", url, bytes.NewBuffer(reqBody)) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to create new request: %w", err) | |
| } | |
| // Set necessary headers | |
| req.Header.Set("Content-Type", ContentType) | |
| req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", d.APIKey)) | |
| // Use the client's HTTP client to make the request | |
| resp, err := d.Client.Do(req) | |
| if err != nil { | |
| return nil, fmt.Errorf("error making HTTP request: %w", err) | |
| } | |
| defer resp.Body.Close() | |
| // Check for non-OK status code | |
| if resp.StatusCode != http.StatusOK { | |
| return nil, fmt.Errorf("received non-OK response status: %d", resp.StatusCode) | |
| } | |
| // Read the response body using io.ReadAll | |
| body, err := io.ReadAll(resp.Body) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to read response body: %w", err) | |
| } | |
| // Unmarshal the response body into the SearchResponse structure | |
| var result SearchResponse | |
| err = json.Unmarshal(body, &result) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to unmarshal response: %w", err) | |
| } | |
| // Return the result | |
| return &result, nil | |
| } | |
| func (d *DappierApp) Search(query string, dataModelID string, opts ...SearchOption) (*SearchResponse, error) { | |
| // Validate inputs | |
| if query == "" || dataModelID == "" { | |
| return nil, errors.New("query and data_model_id cannot be empty") | |
| } | |
| // Create the default request payload with the provided query | |
| requestData := SearchRequest{ | |
| Query: query, | |
| SimilarityTopK: 9, // default value | |
| Ref: "", // default value | |
| NumArticlesRef: 0, // default value | |
| } | |
| // Apply all optional parameters to the request data | |
| for _, opt := range opts { | |
| opt(&requestData) | |
| } | |
| // Marshal the request data into JSON | |
| reqBody, err := json.Marshal(requestData) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to marshal request data: %w", err) | |
| } | |
| // Construct the request URL with the provided data model ID | |
| url := fmt.Sprintf("%s?data_model_id=%s", SearchBaseUrl, dataModelID) | |
| // Create a new HTTP request | |
| req, err := http.NewRequest("POST", url, bytes.NewBuffer(reqBody)) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to create new request: %w", err) | |
| } | |
| // Set necessary headers | |
| req.Header.Set("Content-Type", ContentType) | |
| req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", d.APIKey)) | |
| // Use the client's HTTP client to make the request | |
| resp, err := d.Client.Do(req) | |
| if err != nil { | |
| return nil, fmt.Errorf("error making HTTP request: %w", err) | |
| } | |
| defer resp.Body.Close() | |
| // Check for non-OK status code | |
| if resp.StatusCode != http.StatusOK { | |
| return nil, fmt.Errorf("received non-OK response status: %d", resp.StatusCode) | |
| } | |
| // Read the response body using io.ReadAll | |
| body, err := io.ReadAll(resp.Body) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to read response body: %w", err) | |
| } | |
| // Unmarshal the response body into the SearchResponse structure | |
| var result SearchResponse | |
| err = json.Unmarshal(body, &result) | |
| if err != nil { | |
| return nil, fmt.Errorf("failed to unmarshal response: %w", err) | |
| } | |
| // Check if results are available | |
| if len(result.Response.Results) == 0 { | |
| return nil, errors.New("no search results found") | |
| } | |
| // Return the result | |
| return &result, nil | |
| } |
2 participants
Summary by CodeRabbit
New Features
Documentation