Verás el response JSON como:

```JSON
{"item_id": 5, "q": "somequery"}
```

Ya creaste una API que:

* Recibe requests HTTP en los _paths_ `/` y `/items/{item_id}`.
* Ambos _paths_ toman _operaciones_ `GET` (también conocidas como métodos HTTP).
* El _path_ `/items/{item_id}` tiene un _parámetro de path_ `item_id` que debe ser un `int`.

Você verá a resposta JSON como:

```JSON
{"item_id": 5, "q": "somequery"}
```

Você acabou de criar uma API que:

* Recebe requisições HTTP nos _paths_ `/` e `/items/{item_id}`.
* Ambos _paths_ fazem operações `GET` (também conhecido como _métodos_ HTTP).
* O _path_ `/items/{item_id}` tem um _parâmetro de path_ `item_id` que deve ser um `int`.

Esos parámetros son los que **FastAPI** usará para "resolver" la dependencia.

En ambos casos, tendrá:

* Un parámetro de query `q` opcional que es un `str`.
* Un parámetro de query `skip` que es un `int`, con un valor por defecto de `0`.
* Un parámetro de query `limit` que es un `int`, con un valor por defecto de `100`.

En ambos casos, los datos serán convertidos, validados, documentados en el esquema de OpenAPI, etc.

# https://github.com/apache/lucene-solr/blob/master/lucene/analysis/common/src/resources/org/apache/lucene/analysis/br/stopwords.txt
a
ainda
alem
ambas
ambos
antes
ao
aonde
aos
apos
aquele
aqueles
as
assim
com
como
contra
contudo
cuja
cujas
cujo
cujos
da
das
de
dela
dele
deles
demais
depois
desde
desta
deste
dispoe
dispoem
diversa
diversas
diversos

**Note**: Você pode misturar `def` e `async def` nas suas *funções de operação de rota* tanto quanto necessário e definir cada função usando a melhor opção para você. FastAPI irá fazer a coisa certa com elas.

De qualquer forma, em ambos os casos acima, FastAPI irá trabalhar assincronamente e ser extremamente rápido.

Mas, seguindo os passos acima, ele será capaz de fazer algumas otimizações de performance.

## Detalhes Técnicos { #technical-details }

Aqui vai uma dica do meu ponto de vista bem subjetivo:

* 🚨 Evite usar `Optional[SomeType]`
* Em vez disso ✨ use **`Union[SomeType, None]`** ✨.

Un `Request` también tiene un `request.receive`, que es una función para "recibir" el request body.

El `dict` `scope` y la función `receive` son ambos parte de la especificación ASGI.

Y esas dos cosas, `scope` y `receive`, son lo que se necesita para crear una nueva *Request instance*.

De esta manera, puedes obtener lo mejor de ambos mundos: anotaciones de tipos con **soporte de herramientas** y **filtrado de datos**.

## Verlo en la documentación { #see-it-in-the-docs }

Cuando veas la documentación automática, puedes verificar que el modelo de entrada y el modelo de salida tendrán cada uno su propio JSON Schema:

<img src="/img/tutorial/response-model/image01.png">

Primeiro, vamos ver como editores, mypy e outras ferramentas veriam isso.

`BaseUser` tem os campos base. Então `UserIn` herda de `BaseUser` e adiciona o campo `password`, então, ele incluirá todos os campos de ambos os modelos.

Anotamos o tipo de retorno da função como `BaseUser`, mas na verdade estamos retornando uma instância `UserIn`.

Provee un API en

```
http://localhost:8000/v1/agents/multivac
```

También hay un frontend en

```
http://localhost:8000
```

/// tip | Consejo

Ten en cuenta que ambos tienen el mismo host.

///

Luego, usando el frontend, puedes hacer que el agente de IA haga cosas en tu nombre.