Go Examples
Code examples for integrating WikiRest with Go applications.
Installation
No additional packages required - using the standard library:
// Uses only standard library packages
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
)API Client
Basic client structure
package wikirest
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"time"
)
type Client struct {
APIKey string
BaseURL string
HTTPClient *http.Client
}
func NewClient(apiKey string) *Client {
return &Client{
APIKey: apiKey,
BaseURL: "https://api.wikirest.com/v1",
HTTPClient: &http.Client{
Timeout: 30 * time.Second,
},
}
}
func (c *Client) doRequest(ctx context.Context, method, path string, query url.Values) ([]byte, error) {
reqURL := c.BaseURL + path
if query != nil {
reqURL += "?" + query.Encode()
}
req, err := http.NewRequestWithContext(ctx, method, reqURL, nil)
if err != nil {
return nil, err
}
req.Header.Set("X-API-Key", c.APIKey)
req.Header.Set("Accept", "application/json")
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("API error: %s", string(body))
}
return body, nil
}Search
Search Wikipedia
type SearchResult struct {
ID string `json:"id"`
PageID int `json:"page_id"`
Title string `json:"title"`
Section string `json:"section,omitempty"`
Text string `json:"text"`
ChunkIndex int `json:"chunk_index"`
URL string `json:"url"`
}
type SearchResponse struct {
Hits []SearchResult `json:"hits"`
Query string `json:"query"`
ProcessingTimeMs int `json:"processingTimeMs"`
EstimatedTotalHits int `json:"estimatedTotalHits"`
}
func (c *Client) Search(ctx context.Context, query string, limit int) (*SearchResponse, error) {
params := url.Values{}
params.Set("q", query)
params.Set("limit", fmt.Sprintf("%d", limit))
body, err := c.doRequest(ctx, "GET", "/search", params)
if err != nil {
return nil, err
}
var result SearchResponse
if err := json.Unmarshal(body, &result); err != nil {
return nil, err
}
return &result, nil
}
// Usage
func main() {
client := NewClient("your_api_key")
ctx := context.Background()
results, err := client.Search(ctx, "quantum computing", 5)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found %d results\n", results.EstimatedTotalHits)
for _, hit := range results.Hits {
fmt.Printf("- %s: %s\n", hit.Title, hit.Text[:100])
}
}Get Chunk
Retrieve a single chunk
type Chunk struct {
ID string `json:"id"`
PageID int `json:"page_id"`
Title string `json:"title"`
Section string `json:"section,omitempty"`
Text string `json:"text"`
ChunkIndex int `json:"chunk_index"`
URL string `json:"url"`
WordCount int `json:"word_count,omitempty"`
Modified string `json:"modified,omitempty"`
}
func (c *Client) GetChunk(ctx context.Context, id string) (*Chunk, error) {
body, err := c.doRequest(ctx, "GET", "/chunk/"+id, nil)
if err != nil {
return nil, err
}
var chunk Chunk
if err := json.Unmarshal(body, &chunk); err != nil {
return nil, err
}
return &chunk, nil
}
// Usage
chunk, err := client.GetChunk(ctx, "12345_3")
if err != nil {
log.Fatal(err)
}
fmt.Printf("Chunk from %s: %s\n", chunk.Title, chunk.Text)Get Page
Retrieve full page content
type PageChunk struct {
ID string `json:"id"`
Section string `json:"section,omitempty"`
Text string `json:"text"`
ChunkIndex int `json:"chunk_index"`
}
type Page struct {
PageID int `json:"page_id"`
Title string `json:"title"`
URL string `json:"url"`
Extract string `json:"extract,omitempty"`
Modified string `json:"modified"`
Chunks []PageChunk `json:"chunks"`
TotalChunks int `json:"total_chunks"`
}
func (c *Client) GetPage(ctx context.Context, pageID int) (*Page, error) {
body, err := c.doRequest(ctx, "GET", fmt.Sprintf("/page/%d", pageID), nil)
if err != nil {
return nil, err
}
var page Page
if err := json.Unmarshal(body, &page); err != nil {
return nil, err
}
return &page, nil
}
// Usage
page, err := client.GetPage(ctx, 12345)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Page: %s (%d chunks)\n", page.Title, page.TotalChunks)
for _, chunk := range page.Chunks {
fmt.Printf(" [%s] %s...\n", chunk.Section, chunk.Text[:50])
}Concurrent Requests
Batch search with goroutines
func (c *Client) BatchSearch(ctx context.Context, queries []string, limit int) ([]*SearchResponse, error) {
results := make([]*SearchResponse, len(queries))
errors := make([]error, len(queries))
var wg sync.WaitGroup
// Use semaphore to limit concurrency
sem := make(chan struct{}, 5) // Max 5 concurrent requests
for i, query := range queries {
wg.Add(1)
go func(i int, q string) {
defer wg.Done()
sem <- struct{}{} // Acquire
defer func() { <-sem }() // Release
result, err := c.Search(ctx, q, limit)
results[i] = result
errors[i] = err
}(i, query)
}
wg.Wait()
// Check for errors
for _, err := range errors {
if err != nil {
return nil, err
}
}
return results, nil
}
// Usage
queries := []string{"quantum computing", "machine learning", "blockchain"}
results, err := client.BatchSearch(ctx, queries, 3)
if err != nil {
log.Fatal(err)
}
for i, result := range results {
fmt.Printf("Query '%s': %d results\n", queries[i], result.EstimatedTotalHits)
}HTTP Server Integration
Using WikiRest in an HTTP handler
package main
import (
"encoding/json"
"log"
"net/http"
"os"
)
var wikiClient *Client
func init() {
wikiClient = NewClient(os.Getenv("WIKIREST_API_KEY"))
}
func searchHandler(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query().Get("q")
if query == "" {
http.Error(w, "query parameter 'q' is required", http.StatusBadRequest)
return
}
results, err := wikiClient.Search(r.Context(), query, 10)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(results)
}
func main() {
http.HandleFunc("/search", searchHandler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}