From dd917a8e95d36e17cca2c279af571f37b97cc12f Mon Sep 17 00:00:00 2001 From: Jason Liu Date: Wed, 29 Nov 2023 13:15:08 -0500 Subject: [PATCH] add fastapi --- docs/concepts/fastapi.md | 79 ++++++++++++++++++---------------------- mkdocs.yml | 3 +- 2 files changed, 37 insertions(+), 45 deletions(-) diff --git a/docs/concepts/fastapi.md b/docs/concepts/fastapi.md index 51cd4de..cccbc00 100644 --- a/docs/concepts/fastapi.md +++ b/docs/concepts/fastapi.md @@ -2,18 +2,26 @@ [FastAPI](https://fastapi.tiangolo.com/) is an enjoyable tool for building web applications in Python. It is well known for its integration with `Pydantic` models, which makes defining and validating data structures straightforward and efficient. In this guide, we explore how simple functions that return `Pydantic` models can seamlessly integrate with `FastAPI`. +## Why Choose FastAPI and Pydantic? + +- FastAPI is a modern, high-performance web framework for building APIs with Python. +- Supports OpenAPI and JSON Schema for automatic documentation and validation. +- Supports AsyncIO for asynchronous programming leveraging the AsyncOpenAI() client + ## Code Example: Starting a FastAPI App with a POST Request The following code snippet demonstrates how to start a `FastAPI` app with a POST endpoint. This endpoint accepts and returns data defined by a `Pydantic` model. ```python +import instructor + from fastapi import FastAPI from pydantic import BaseModel -import instructor -from openai import OpenAI +from openai import AsyncOpenAI # Enables response_model -client = instructor.patch(OpenAI()) +client = instructor.patch(AsyncOpenAI()) +app = FastAPI() class UserData(BaseModel): # This can be the model for the input data @@ -23,70 +31,53 @@ class UserDetail(BaseModel): name: str age: int -app = FastAPI() @app.post("/endpoint", response_model=UserDetail) def endpoint_function(data: UserData) -> UserDetail: - user_detail = client.chat.completions.create( + user_detail = await client.chat.completions.create( model="gpt-3.5-turbo", response_model=UserDetail, messages=[ - {"role": "user", "content": data.query}, + {"role": "user", "content": f"Extract: `{data.query}`"}, ] ) return user_detail ``` -### Utilizing FastAPI Backend as a Plugin for GPT +## Streaming Responses with FastAPI -`FastAPI`'s compatibility with OpenAI specifications, particularly when integrated with `Pydantic` models and the `instructor` library, enhances the backend's capacity to serve as a plugin for GPT models. This integration enables a seamless connection between FastAPI's robust API development capabilities and LLMs. +`FastAPI` supports streaming responses, which is useful for returning large amounts of data. This feature is particularly useful when working with large language models (LLMs) that generate a large amount of data. -#### Key Points of Integration +```python hl_lines="6-7" +# Route to handle SSE events and return users +@app.post("/extract", response_class=StreamingResponse) +async def extract(userdata: UserData): + users = await client.chat.completions.create( + model="gpt-3.5-turbo", + response_model=Iterable[UserDetail], + stream=True, + messages=[ + {"role": "user", "content": data.query}, + ] + ) -1. **Seamless Integration with GPT Models**: Direct interaction with GPT models using `instructor`. -2. **Enhanced Backend Functionality**: Acts as an LLM-augmented plugin for dynamic request processing. -3. **Maintaining Core FastAPI Benefits**: Automatic validation, comprehensive documentation, and ease of testing are maintained. + async def generate(): + for user in users: + resp_json = user.model_dump_json() + yield f"data: {resp_json}" + yield "data: [DONE]" + + return StreamingResponse(generate(), media_type="text/event-stream") +``` ## Automatic Documentation with FastAPI FastAPI leverages the OpenAPI specification to automatically generate a dynamic and interactive documentation page, commonly referred to as the `/docs` page. This feature is incredibly useful for developers, as it offers a live environment to test API endpoints directly through the browser. -### How to Use the `/docs` Page for Testing - To explore the capabilities of your API, follow these steps: 1. Run the API using the Uvicorn command: `uvicorn main:app --reload`. 2. Open your web browser and navigate to `http://127.0.0.1:8000/docs`. 3. You will find an interactive UI where you can send different requests to your API and see the responses in real-time. -### Example Queries to Try - -Here are various types of queries you can test. These examples demonstrate how the API can process and understand different formats of data input: - -- **Simple Direct Statements**: - - "Identify that Sarah is 30 years old." (A straightforward statement) - - "Note that Michael is 42 years old." (Directly provides the required information) - -- **Embedded in Sentences**: - - "During the meeting, it was mentioned that Kevin is 28 years old." (Information embedded within a sentence) - - "In her bio, it says Emma is 35 years old." (Extracting details from a biographical note) - -- **Question Format**: - - "How old is Daniel who is 22 years old?" (Query posed as a question) - - "What is the age of Rachel who is 29?" (Another question-based format) - -Utilize the interactive UI of the `/docs` page to experiment with these queries and observe how the API processes and responds. - ![Screenshot of FastAPI /docs page](response.png) - -## Why Choose FastAPI and Pydantic? - -- **Efficiency**: Simplifies the development and maintenance of APIs. -- **Scalability**: Facilitates the growth of your application. -- **Integration**: Easy integration with modern Python features and libraries. - -## Conclusion - -Using `FastAPI` in conjunction with `Pydantic` models not only simplifies the development of robust APIs but also ensures that they are well-documented and easy to test. This approach leads to more maintainable and scalable code, making `FastAPI` a popular choice for modern web API development. - -For more detailed information and advanced usage, refer to the [FastAPI Documentation](https://fastapi.tiangolo.com/). diff --git a/mkdocs.yml b/mkdocs.yml index 1c2b392..7ab464e 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,4 +1,4 @@ -site_name: Instructor (openai_function_call) +site_name: Instructor site_author: Jason Liu site_description: Enhancing OpenAI function calling with Pydantic repo_name: instructor @@ -134,6 +134,7 @@ nav: - Missing: "concepts/maybe.md" - Patching: 'concepts/patching.md' - Streaming: "concepts/lists.md" + - FastAPI: 'concepts/fastapi.md' - Caching: 'concepts/caching.md' - Validators: "concepts/reask_validation.md" - Distillation: "concepts/distillation.md"