> For the complete documentation index, see [llms.txt](https://docs.geopard.tech/geopard-tutorials/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.geopard.tech/geopard-tutorials/pl/przewodnik-po-produkcie-aplikacja-webowa/equation-based-analytics/catalog-of-custom-functions.md).

# Katalog funkcji niestandardowych

Te funkcje enkapsulują złożony kod Python, umożliwiając łatwe wdrażanie zaawansowanych przekształceń i obliczeń danych.

GeoPard udostępnia obszerny katalog funkcji niestandardowych, które poprawiają czytelność i funkcjonalność analiz opartych na równaniach. Funkcje te hermetyzują złożony `python` kod, ułatwiając zaawansowane przekształcanie i obliczanie danych.

### Wprowadź równanie

<figure><img src="https://docs.geopard.tech/~gitbook/image?url=https%3A%2F%2F3272281156-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FYICBELdyAXXebKAzfLOR%252Fuploads%252FdHTdBE1CN2gSJbE7Bfo0%252Fimage.png%3Falt%3Dmedia%26token%3Dd8e3544f-feca-43a6-b6a1-f1305068de88&#x26;width=768&#x26;dpr=4&#x26;quality=100&#x26;sign=508ec9e0&#x26;sv=2" alt=""><figcaption><p>Wprowadź równanie</p></figcaption></figure>

Lista dostępnych, gotowych funkcji do tworzenia bardziej intuicyjnych i łatwiejszych w utrzymaniu równań w GeoPard znajduje się w pakiecie `geopard` :

### fill\_gaps\_with\_k\_neighbors

```python
# input_data is a Dataset attribute layer (e.g., Yield, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)
```

Ta funkcja uzupełnia luki lub zera w danych zbioru danych za pomocą algorytmu K najbliższych sąsiadów. Określając `input_data` — zmienną (zbiór danych z wybranym atrybutem) — oraz liczbę sąsiadów `k`, możesz płynnie uzupełnić brakujące wartości, zapewniając ciągłość i integralność danych.

Funkcja sprawdza się, gdy luki w danych są rozproszone na polu, a nie skupione w określonej części jego granicy.

### determine\_data\_similarity

```python
similarity = geopard.determine_data_similarity(yield_2023, yield_2024)
```

Użyj tej funkcji, aby obliczyć podobieństwo między dwoma zbiorami danych dla każdego piksela. Zmienne `data_layer_1` i `data_layer_2` powinny przedstawiać **ten sam pomiar** w tych samych **jednostkach** , aby zapewnić miarodajne porównanie. Podając zmienne `data_layer_1` i `data_layer_2` powiązane ze zbiorami danych, możesz wygenerować mapę podobieństwa z wartościami od 0 do 1, co ułatwia badania porównawcze i rozpoznawanie wzorców.

### determine\_data\_similarity\_from\_normalized

```python
layer_1_norm = geopard.normalize_data(layer_1)
layer_2_norm = geopard.normalize_data(layer_2)

similarity = geopard.determine_data_similarity_from_normalized(layer_1_norm, layer_2_norm)
```

Użyj tej funkcji, aby obliczyć podobieństwo między dwoma znormalizowanymi zbiorami danych dla każdego piksela. Normalizacja jest zalecana, gdy oryginalne `data_layer_1` i `data_layer_2` mają różne skale lub jednostki. Po przekazaniu tych zbiorów danych jako danych wejściowych funkcja generuje mapę podobieństwa z wartościami od 0 do 1, dzięki czemu nadaje się ona do badań porównawczych, rozpoznawania wzorców i analizy spójności przestrzennej.

### determine\_low\_high\_similarity

```python
zones = geopard.determine_low_high_similarity(soil_ph, yield_layer)
```

Ta funkcja ocenia podobieństwo między dwoma zbiorami danych w zakresie od niskiego do wysokiego. Podając zmienne `data_layer_1` i `data_layer_2` powiązane ze zbiorami danych, otrzymasz skategoryzowaną mapę podobieństwa, wskazującą kombinacje takie jak niskie–niskie, niskie–wysokie, wysokie–niskie i wysokie–wysokie. Przydaje się ona do szczegółowej klasyfikacji danych.

### get\_value\_for\_zone

```python
zone_3_values = geopard.get_value_for_zone(yield_layer, zone_map, zone_id=3)
```

Użyj tej funkcji, aby wyodrębnić wszystkie wartości atrybutu zbioru danych w obrębie jednej strefy. Podaj `data_layer` (warstwę atrybutu), `zones_layer` (mapa stref), oraz `zone_id` (numer strefy), aby wyodrębnić wartości do analizy, takie jak plon, dawka aplikacji lub norma wysiewu, w obrębie tej strefy.

### drop\_value

```python
clean_layer = geopard.drop_value(elevation_layer, value_to_drop=0)
```

Ta funkcja pozwala usunąć określone wartości z atrybutu zbioru danych. Podając `data_layer` oraz `value_to_drop`, możesz oczyścić zbiór danych, eliminując te wartości z wyniku i zastępując je technicznie przez `NaN`.

### normalize\_data

```python
ndvi_normalized = geopard.normalize_data(ndvi_layer)
```

Ta funkcja normalizuje atrybut zbioru danych. Przekazując `data_layer`, możesz przeskalować dane do standardowego zakresu od 0 do 1, co ułatwia porównywanie i łączenie różnych zbiorów danych.

### calculate\_total\_applied\_fertilizer

```python
applications = [urea_rate, map_rate]
coefficients = [1.0, 1.0]  # use 1.0 to keep units, or adjust for product concentration

total_applied = geopard.calculate_total_applied_fertilizer(applications, coefficients)
```

Ta funkcja oblicza całkowitą ilość zastosowanego nawozu w jednostkach na powierzchnię (np. kg/ha, l/ha, gal/ac itp.). Podaj `application_list` zbiory danych z atrybutami AppliedRate oraz odpowiadającą im `active_ingredient_coefficient_list` dla produktów nawozowych, aby obliczyć rzeczywistą całkowitą ilość zastosowanego nawozu w jednostkach (np. kg, l, gal itp.).

### calculate\_total\_applied\_nitrogen

```python
applications = [urea_rate, uan_rate]
nitrogen_coefficients = [0.46, 0.32]  # N fraction (active ingredient) in each product

N_total_applied = geopard.calculate_total_applied_nitrogen(applications, nitrogen_coefficients)
```

Ta funkcja oblicza całkowitą ilość zastosowanego azotu w kg/ha. Podaj `application_list` zbiory danych z atrybutami AppliedRate oraz odpowiadającą im `active_ingredient_coefficient_list` dla produktów azotowych, aby przeliczyć rzeczywistą ilość azotu na kg/ha. Dzięki temu można dokładnie obliczyć całkowitą ilość zastosowanego azotu, co ma kluczowe znaczenie dla planowania rolniczego i oceny zrównoważonego rozwoju. Wynik jest używany jako `N_total_applied` w[`geopard.calculate_nitrogen_use_efficiency`](#calculate_nitrogen_use_efficiency).

### calculate\_nitrogen\_uptake

```python
N_uptake = geopard.calculate_nitrogen_uptake(
    yield_wet_tha=yield_layer,
    moisture_pct=moisture_layer,
    protein_pct=protein_layer,
    protein_crop_correction_coefficient=6.25
)
```

Ta funkcja określa pobranie azotu w kg/ha. Podaj `yield_wet_tha`, `moisture_pct`, `protein_pct` ze zbioru danych o plonie oraz `protein_crop_correction_coefficient` przedstawiający zależność białka wiążącego od pobrania azotu, można ocenić efektywność wykorzystania azotu w produkcji roślinnej. Wynik jest używany jako `N_uptake` w[`geopard.calculate_nitrogen_use_efficiency`](#calculate_nitrogen_use_efficiency) .

### calculate\_nitrogen\_use\_efficiency

```python
NUE_pct = geopard.calculate_nitrogen_use_efficiency(N_total_applied, N_uptake)
```

Za pomocą tej funkcji oblicz efektywność wykorzystania azotu jako wartość procentową. Podając [`N_total_applied`](#calculate_total_applied_nitrogen) oraz [`N_uptake`](#calculate_nitrogen_uptake) jako zmienne (z poprzednich funkcji), możesz zmierzyć skuteczność nawożenia azotem, co pomaga zoptymalizować zużycie nawozów.

### calculate\_costs

```python
rates = [seed_rate, fertilizer_rate]
prices = [1.2, 0.8]  # cena jednostkowa dla każdej warstwy ze stawką
costs = geopard.calculate_costs(rates, prices)
```

Za pomocą tej funkcji oblicz całkowite koszty na podstawie dawek aplikacji i cen. Podając `application_rate_list` listę zbiorów danych z atrybutami AppliedRate oraz odpowiadającą jej `price_per_unit_list`, możesz zsumować wydatki związane z różnymi pracami rolniczymi, co ułatwia zarządzanie budżetem i planowanie finansowe. Wynik jest używany jako `costs` w[`geopard.calculate_profit`](#calculate_profit).

### calculate\_revenue

```python
revenue = geopard.calculate_revenue(yield_as_mass=yield_layer, yield_price_per_unit=0.25)
```

Za pomocą tej funkcji oblicz przychód z zestawu danych dotyczącego plonu. Podając `yield_as_mass` powiązane z atrybutem Yield zestawu danych oraz `yield_price_per_unit`, możesz oszacować dochód z produkcji roślinnej, co ułatwia ocenę ekonomiczną. Wynik jest używany jako `costs` w[`geopard.calculate_profit`](#calculate_profit) .

### calculate\_profit

```python
profit = geopard.calculate_profit(revenue, costs)
```

Za pomocą tej funkcji oblicz zysk, odejmując koszty od przychodu. Podając [`revenue`](#calculate_revenue) oraz [`costs`](#calculate_costs) jako zmienne (z poprzednich funkcji), możesz łatwo obliczyć zysk finansowy z działalności rolniczej, co wspiera analizę rentowności i podejmowanie decyzji strategicznych.

### fill\_value\_for\_range

```python
# zachowaj tylko wartości z zakresu od 10 do 20, pozostałe zastąp wartością 0
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)
```

Ta funkcja filtruje wartości mieszczące się w określonym zakresie w tablicy `input` . Podaj `input` tablicę oraz opcjonalnie `min_value` i `max_value` progi, możesz wyodrębnić wartości mieszczące się w żądanym zakresie. Parametr `value_to_fill` umożliwia zastąpienie wartości spoza zakresu określoną wartością, usprawniając filtrowanie i normalizację danych.

### calculate\_per\_pixel\_mae

```python
mae_layer = geopard.calculate_per_pixel_mae(predicted_yield, observed_yield)
```

Użyj tej funkcji, aby obliczyć średni błąd bezwzględny (MAE) dla każdego piksela między dwoma zbiorami danych. Funkcja tworzy przestrzenną mapę różnic bezwzględnych. „Różnica bezwzględna” to po prostu wielkość różnicy między odpowiadającymi sobie wartościami pikseli, niezależnie od tego, która z nich jest większa.

Funkcja pomaga wskazać obszary o większych rozbieżnościach.

### calculate\_per\_pixel\_relative\_deviation

```python
relative_dev = geopard.calculate_per_pixel_relative_deviation(observed_yield, modeled_yield)
```

Ta funkcja oblicza odchylenie względne dla każdego piksela między dwoma zbiorami danych, wyrażając różnicę jako procent wartości w `dataset_1`. Zasadniczo pokazuje, o ile wartość piksela różni się od odpowiadającej jej wartości w `dataset_1` w ujęciu proporcjonalnym.

To podejście jest szczególnie przydatne podczas analizy zmienności właściwości gleby, plonów lub danych teledetekcyjnych, ponieważ pomaga szybko dostrzec obszary o znacznych różnicach proporcjonalnych.

### calculate\_difference

```python
difference = geopard.calculate_difference(yield_2024, yield_2023)
```

Ta funkcja odejmuje jeden zbiór danych od drugiego, tworząc mapę różnic. Wskazuje obszary, w których wartości jednego zbioru są większe lub mniejsze niż wartości drugiego, co ułatwia dostrzeżenie trendów i zmian zachodzących w czasie.

To narzędzie jest szczególnie przydatne do wizualizacji zmienności właściwości gleby, plonów lub danych teledetekcyjnych. Pomaga szybko zidentyfikować obszary, które mogą wymagać dalszej analizy lub interwencji.

### calculate\_relative\_difference

```python
relative_diff = geopard.calculate_relative_difference(yield_2024, yield_2023)
```

Ta funkcja oblicza różnicę względną dla każdego piksela, normalizując różnicę między zbiorami danych za pomocą wartości ze zbioru `dataset_2`. Dzięki temu pokazuje, jak duża jest zmiana w stosunku do wartości `dataset_2`.

Takie porównanie proporcjonalne jest szczególnie przydatne podczas pracy ze zbiorami danych o różnych skalach. Pomaga ujawnić względne zmiany właściwości gleby, plonów lub odczytów czujników oraz wskazać obszary o zauważalnej zmienności.

### calculate\_normalized\_difference

```python
normalized_diff = geopard.calculate_normalized_difference(layer_1, layer_2)
```

Ta funkcja oblicza różnicę znormalizowaną dla każdego piksela, skalując oba zbiory danych względem ich globalnej wartości maksymalnej. Dzięki temu można je bezpośrednio porównywać, nawet jeśli początkowo miały różne zakresy wartości.

Wynikowa mapa zapewnia czytelny obraz zmienności właściwości gleby, plonów i danych teledetekcyjnych, umożliwiając szybkie wskazanie i ocenę kluczowych różnic.

### build\_zones\_by\_intervals

```python
# przedziały do wyznaczania stref
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

# użycie
zones = geopard.build_zones_by_intervals(
    layer, 
    intervals
)
```

Ta funkcja tworzy mapę stref zarządzania, klasyfikując ciągłą warstwę rastrową do odrębnych stref na podstawie zdefiniowanych przez użytkownika przedziałów wartości.

Każdy przedział określa strefę, a każdy piksel jest przypisywany do strefy, której zakres wartości obejmuje wartość tego piksela. Piksele, które nie pasują do żadnego przedziału, otrzymują wartość -1.

To podejście do wyznaczania stref jest powszechnie stosowane do przekształcania map plonów, właściwości gleby lub indeksów teledetekcyjnych w strefy zarządzania, które można wykorzystać w aplikacji zmiennej dawki.

**Typowe zastosowania**

* Tworzenie stref zarządzania na podstawie warstw plonów, NDVI lub właściwości gleby
* Przygotowywanie map stref do obliczania dawek nawozów lub wysiewu
* Podział pól na jednorodne strefy na potrzeby podejmowania decyzji

### calculate\_nutrient\_rate\_as\_active\_ingredients\_per\_zone

```python
# opcje target_nutrient
target_nutrient_option1 = 50 # stała wartość
# LUB
target_nutrient_option2 = {1: 20, 2: 40} # słownik z wartościami dla poszczególnych stref
# LUB
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # ciągła warstwa rastrowa

# opcje applied_nutrient_operations
applied_operations = [
    5,                                      # operation1 jako stała liczbowa
    {1: 2, 2: 4},                           # operation2 jako słownik wartości dla stref
    np.array([[1, 1], [2, 3]], dtype=float) # operation3 jako ciągła warstwa rastrowa
]

# użycie
rates_as_active_ingredients = geopard.calculate_nutrient_rate_as_active_ingredients_per_zone(
    zone_map, 
    target_nutrient, 
    plant_available_soil_nutrient, 
    applied_nutrient_operations = applied_operations # lub []
)
```

Ta funkcja oblicza wymaganą dawkę składnika pokarmowego (substancji czynnej) dla każdej strefy zarządzania.

Obliczenie uwzględnia:

* docelowy poziom składnika pokarmowego,
* dostępność składnika pokarmowego w glebie dla roślin,
* składniki pokarmowe zastosowane wcześniej (obornik, nawozy, poferment itp.).

Zastosowane składniki pokarmowe można podać jako stałe, wartości dla poszczególnych stref, warstwy rastrowe lub dowolne ich połączenie. Wszystkie dane wejściowe są automatycznie przeliczane i sumowane dla każdej strefy.

Domyślnie wymagana dawka jest obliczana jako różnica między docelowym poziomem składnika pokarmowego a sumą jego zasobów w glebie i ilości zastosowanej. Wynik jest zwracany jako mapa rastrowa, na której każda strefa ma jednolitą dawkę składnika pokarmowego.

### convert\_active\_ingredient\_and\_product

```python
# współczynnik przeliczeniowy między substancją czynną a produktem i odwrotnie
corrected_coefficient = 1.5  # stały współczynnik
# LUB
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # współczynniki dla poszczególnych pikseli

# użycie
rates_as_products = geopard.convert_active_ingredient_and_product(
    layer, 
    corrected_coefficient
)
```

Ta funkcja przelicza warstwę rastrową między dawkami **substancji czynnej a dawkami produktu** za pomocą współczynnika korekcyjnego.

Wartość `corrected_coefficient` może być pojedynczą wartością typu **float** (stosowaną do wszystkich pikseli) lub macierzą **współczynników** (przeliczenie dla poszczególnych pikseli). Funkcja służy zazwyczaj do przeliczania wyliczonego zapotrzebowania na składnik pokarmowy (substancję czynną) na rzeczywistą dawkę produktu lub odwrotnie, na podstawie składu nawozu albo stężenia składnika pokarmowego.

Przeliczenie jest wykonywane dla każdego piksela z osobna, z zachowaniem przestrzennego układu pierwotnej warstwy.

**Typowe zastosowania**

* Przeliczanie dawek składników pokarmowych na dawki nawozu
* Dostosowywanie map aplikacyjnych do stężenia składnika pokarmowego
* Przygotowywanie końcowych map aplikacyjnych dla maszyn

### map\_value\_by\_zone

```python
# przypisz jedną wartość do wszystkich stref
planned_yield = geopard.map_value_by_zone(
    zone_map,
    3.0
)

# LUB: przypisz różne wartości do poszczególnych stref
planned_yield = geopard.map_value_by_zone(
    zone_map,
    {1: 2.91, 2: 3.0, 3: 3.06}
)

# LUB: zagreguj istniejącą warstwę rastrową według stref
p_zone_median = geopard.map_value_by_zone(
    zone_map,
    p2o5,
    aggregation_logic="median"
)
```

Ta funkcja przekształca wartości skalarne, słowniki z wartościami dla poszczególnych stref lub warstwy rastrowe w raster oparty na strefach.

Każdy prawidłowy piksel otrzymuje wartość przypisaną do odpowiadającej mu strefy. W przypadku danych rastrowych wartości są agregowane w obrębie każdej strefy przy użyciu `mean`, `median`, `min`, lub `max`, skutecznie eliminując zmienność w obrębie strefy.

Brakujące wartości w słowniku i piksele nodata otrzymują określoną wartość `default` (domyślnie NaN).

**Typowe zastosowania**

* Tworzenie pikselowych docelowych plonów planowanych na podstawie wartości przypisanych do stref
* Przekształcanie zaleceń nawozowych przypisanych do stref w rastry zmiennego dawkowania
* Ujednolicanie zmienności składników pokarmowych gleby w obrębie stref zarządzania
* Przygotowywanie parametrów dla stref do pikselowych obliczeń NumPy

### calculate\_dose\_by\_nutrient\_balance

```python
# oblicz dawkę nawozu handlowego
ammophos_dose = geopard.calculate_dose_by_nutrient_balance(
    zone_map,
    planned_yield={1: 2.91, 2: 3.0, 3: 3.06},
    soil_nutrient=p2o5,
    removal_per_yield_unit=12.5,
    soil_use_coefficient=0.2,
    fertilizer_use_coefficient=0.4,
    correction_coefficient=1.5,
    product_nutrient_share=0.46,
    min_dose=50,
    max_dose=100
)
```

Ta funkcja oblicza dawki nawozu dla poszczególnych pikseli, bilansując pobranie składników pokarmowych przez uprawę z ich dostępnością w glebie.

Obliczenia uwzględniają planowany plon, pobranie składników pokarmowych przez uprawę, dostępne składniki pokarmowe w glebie, współczynniki wykorzystania składników z gleby i nawozu oraz współczynniki korekcyjne. Wymaganą ilość czystego składnika można opcjonalnie przeliczyć na dawkę nawozu handlowego za pomocą parametru `product_nutrient_share`.

Obsługiwane są skalarne wartości plonu planowanego, wartości w słowniku lub rastrze. Wartości składników pokarmowych w glebie można podawać dla poszczególnych pikseli lub agregować według stref. Końcowe dawki można ograniczyć minimalnymi i maksymalnymi wartościami aplikacji oraz zaokrąglić do liczb całkowitych.

**Typowe zastosowania**

* Tworzenie map zmiennego dawkowania nawozów P₂O₅ i K₂O
* Obliczanie uzupełnienia składników pokarmowych na podstawie planowanego plonu uprawy
* Uwzględnianie zasobności gleby w składniki pokarmowe i efektywności wykorzystania nawozu
* Przeliczanie zapotrzebowania na czysty składnik na dawki nawozu handlowego
* Tworzenie map nawożenia gotowych do użycia przez maszyny rolnicze

### estimate\_texture\_class\_based\_on\_usda

```python
usda_texture = geopard.estimate_texture_class_based_on_usda(
    sand_pct_layer,
    silt_pct_layer,
    clay_pct_layer
)
```

Ta funkcja szacuje teksturę gleby według klasyfikacji USDA dla każdego piksela na podstawie procentowej zawartości piasku, pyłu i iłu.

Podaj trzy warstwy rastrowe wyrażone w procentach (0–100), przedstawiające frakcje granulometryczne. Wynikiem są <mark style="background-color:green;">nazwy klas USDA, takie jak</mark> *<mark style="background-color:green;">sand, loamy\_sand, sandy\_loam, loam, silt\_loam, sandy\_clay\_loam, clay\_loam, silty\_clay\_loam, silty\_clay lub undefined</mark>* <mark style="background-color:green;">w przypadku nieprawidłowych danych wejściowych.</mark>

### estimate\_texture\_class\_based\_on\_fao\_wrb

```python
fao_wrb_texture = geopard.estimate_texture_class_based_on_fao_wrb(
    sand_pct_layer,
    silt_pct_layer,
    clay_pct_layer
)
```

Ta funkcja szacuje klasę tekstury gleby według klasyfikacji FAO/WRB (ISO 11277) dla każdego piksela na podstawie procentowej zawartości piasku, pyłu i iłu.

Podaj trzy warstwy rastrowe wyrażone w procentach (0–100), przedstawiające frakcje granulometryczne. Wynikiem są <mark style="background-color:green;">kody klas FAO/WRB, takie jak</mark> *<mark style="background-color:green;">S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC lub undefined</mark>* <mark style="background-color:green;">w przypadku nieprawidłowych danych wejściowych</mark>.

### calculate\_soil\_bulk\_density

```python
bulk_density = geopard.calculate_soil_bulk_density(texture_class_layer, som_pct_layer)
```

Ta funkcja oblicza <mark style="background-color:green;">gęstość objętościową gleby (g/cm³) na podstawie klasy tekstury i opcjonalnej zawartości materii organicznej gleby (SOM)</mark>.

Warstwa `texture_class_layer` powinna zawierać nazwy lub kody klas wygenerowane przez funkcję tekstury [USDA](#estimate_texture_class_based_on_usda) lub funkcję tekstury [FAO/WRB](#estimate_texture_class_based_on_fao_wrb) wspomnianą powyżej.

Jeśli `som_pct_layer` jest podana jako wartość procentowa, funkcja koryguje gęstość objętościową gleby z uwzględnieniem SOM. W przeciwnym razie zwraca wartości gęstości objętościowej gleby w g/cm³ przypisane do klas tekstury gleby zgodnie z tabelą USDA lub FAO/WRB.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.geopard.tech/geopard-tutorials/pl/przewodnik-po-produkcie-aplikacja-webowa/equation-based-analytics/catalog-of-custom-functions.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
