instructor

1
from pydantic import BaseModel
2
from fastapi import FastAPI
3
from openai import AsyncOpenAI
4
import instructor
5
import logfire
6
import asyncio
7
from collections.abc import Iterable
8
from fastapi.responses import StreamingResponse
9

10

11
class UserData(BaseModel):
12
    query: str
13

14

15
class MultipleUserData(BaseModel):
16
    queries: list[str]
17

18

19
class UserDetail(BaseModel):
20
    name: str
21
    age: int
22

23

24
app = FastAPI()
25
openai_client = AsyncOpenAI()
26
logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record="all"))
27
logfire.instrument_fastapi(app)
28
logfire.instrument_openai(openai_client)
29
client = instructor.from_openai(openai_client)
30

31

32
@app.post("/user", response_model=UserDetail)
33
async def endpoint_function(data: UserData) -> UserDetail:
34
    user_detail = await client.chat.completions.create(
35
        model="gpt-3.5-turbo",
36
        response_model=UserDetail,
37
        messages=[
38
            {"role": "user", "content": f"Extract: `{data.query}`"},
39
        ],
40
    )
41
    logfire.info("/User returning", value=user_detail)
42
    return user_detail
43

44

45
@app.post("/many-users", response_model=list[UserDetail])
46
async def extract_many_users(data: MultipleUserData):
47
    async def extract_user(query: str):
48
        user_detail = await client.chat.completions.create(
49
            model="gpt-3.5-turbo",
50
            response_model=UserDetail,
51
            messages=[
52
                {"role": "user", "content": f"Extract: `{query}`"},
53
            ],
54
        )
55
        logfire.info("/User returning", value=user_detail)
56
        return user_detail
57

58
    coros = [extract_user(query) for query in data.queries]
59
    return await asyncio.gather(*coros)
60

61

62
@app.post("/extract", response_class=StreamingResponse)
63
async def extract(data: UserData):
64
    supressed_client = AsyncOpenAI()
65
    logfire.instrument_openai(supressed_client, suppress_other_instrumentation=False)
66
    client = instructor.from_openai(supressed_client)
67
    users = await client.chat.completions.create(
68
        model="gpt-3.5-turbo",
69
        response_model=Iterable[UserDetail],
70
        stream=True,
71
        messages=[
72
            {"role": "user", "content": data.query},
73
        ],
74
    )
75

76
    async def generate():
77
        with logfire.span("Generating User Response Objects"):
78
            async for user in users:
79
                resp_json = user.model_dump_json()
80
                logfire.info("Returning user object", value=resp_json)
81

82
                yield resp_json
83

84
    return StreamingResponse(generate(), media_type="text/event-stream")
85