Basic FastAPI Server

1
from openai import OpenAI
2
from composio import Composio
3
from composio_openai import OpenAIProvider
4
import os
5
6
def run_gmail_agent(
7
    composio_client: Composio[OpenAIProvider],
8
    openai_client: OpenAI,
9
    user_id: str,  # Composio uses the User ID to store and access user-level authentication tokens.
10
    prompt: str,
11
):
12
    """
13
    Run the Gmail agent using composio and openai clients.
14
    """
15
    # Step 1: Fetch the necessary Gmail tools list with Composio
16
    tools = composio_client.tools.get(
17
        user_id=user_id,
18
        tools=[
19
            "GMAIL_FETCH_EMAILS",
20
            "GMAIL_SEND_EMAIL",
21
            "GMAIL_CREATE_EMAIL_DRAFT"
22
        ]
23
    )
24
25
    # Step 2: Use OpenAI to generate a response based on the prompt and available tools
26
    response = openai_client.chat.completions.create(
27
        model="gpt-4.1",
28
        tools=tools,
29
        messages=[{"role": "user", "content": prompt}],
30
    )
31
32
    # Step 3: Handle tool calls with Composio and return the result
33
    result = composio_client.provider.handle_tool_calls(response=response, user_id=user_id)
34
    return result

1
from composio import Composio
2
from composio_openai import OpenAIProvider
3
4
def create_auth_config(composio_client: Composio[OpenAIProvider]):
5
    """
6
    Create a auth config for the gmail toolkit.
7
    """
8
    client_id = os.getenv("GMAIL_CLIENT_ID")
9
    client_secret = os.getenv("GMAIL_CLIENT_SECRET")
10
    if not client_id or not client_secret:
11
        raise ValueError("GMAIL_CLIENT_ID and GMAIL_CLIENT_SECRET must be set")
12
13
    return composio_client.auth_configs.create(
14
        toolkit="GMAIL",
15
        options={
16
            "name": "default_gmail_auth_config",
17
            "type": "use_custom_auth",
18
            "auth_scheme": "OAUTH2",
19
            "credentials": {
20
                "client_id": client_id,
21
                "client_secret": client_secret,
22
            },
23
        },
24
    )

1
def fetch_auth_config(composio_client: Composio[OpenAIProvider]):
2
    """
3
    Fetch the auth config for a given user id.
4
    """
5
    auth_configs = composio_client.auth_configs.list()
6
    for auth_config in auth_configs.items:
7
        if auth_config.toolkit == "GMAIL":
8
            return auth_config
9
10
    return None

1
from fastapi import FastAPI
2
3
# Function to initiate a connected account
4
def create_connection(composio_client: Composio[OpenAIProvider], user_id: str):
5
    """
6
    Create a connection for a given user id and auth config id.
7
    """
8
    # Fetch or create the auth config for the gmail toolkit
9
    auth_config = fetch_auth_config(composio_client=composio_client)
10
    if not auth_config:
11
        auth_config = create_auth_config(composio_client=composio_client)
12
13
    # Create a connection for the user
14
    return composio_client.connected_accounts.initiate(
15
        user_id=user_id,
16
        auth_config_id=auth_config.id,
17
    )
18
19
# Setup FastAPI
20
app = FastAPI()
21
22
# Connection initiation endpoint
23
@app.post("/connection/create")
24
def _create_connection(
25
    request: CreateConnectionRequest,
26
    composio_client: ComposioClient,
27
) -> dict:
28
    """
29
    Create a connection for a given user id.
30
    """
31
    # For demonstration, using a default user_id. Replace with real user logic in production.
32
    user_id = "default"
33
34
    # Create a new connection for the user
35
    connection_request = create_connection(composio_client=composio_client, user_id=user_id)
36
    return {
37
        "connection_id": connection_request.id,
38
        "redirect_url": connection_request.redirect_url,
39
    }

1
import os
2
import typing_extensions as te
3
4
from composio import Composio
5
from composio_openai import OpenAIProvider
6
7
from fastapi import Depends
8
9
_composio_client: Composio[OpenAIProvider] | None = None
10
11
def provide_composio_client():
12
    """
13
    Provide a Composio client.
14
    """
15
    global _composio_client
16
    if _composio_client is None:
17
        _composio_client = Composio(provider=OpenAIProvider())
18
    return _composio_client
19
20
21
ComposioClient = te.Annotated[Composio, Depends(provide_composio_client)]
22
"""
23
A Composio client dependency.
24
"""

1
def check_connected_account_exists(
2
    composio_client: Composio[OpenAIProvider],
3
    user_id: str,
4
):
5
    """
6
    Check if a connected account exists for a given user id.
7
    """
8
    # Fetch all connected accounts for the user
9
    connected_accounts = composio_client.connected_accounts.list(
10
        user_ids=[user_id],
11
        toolkit_slugs=["GMAIL"],
12
    )
13
14
    # Check if there's an active connected account
15
    for account in connected_accounts.items:
16
        if account.status == "ACTIVE":
17
            return True
18
19
        # Ideally you should not have inactive accounts, but if you do, delete them.
20
        print(f"[warning] inactive account {account.id} found for user id: {user_id}")
21
    return False
22
23
def validate_user_id(user_id: str, composio_client: ComposioClient):
24
    """
25
    Validate the user id, if no connected account is found, create a new connection.
26
    """
27
    if check_connected_account_exists(composio_client=composio_client, user_id=user_id):
28
        return user_id
29
30
    raise HTTPException(
31
        status_code=404, detail={"error": "No connected account found for the user id"}
32
    )
33
34
# Endpoint: Run the Gmail agent for a given user id and prompt
35
@app.post("/agent")
36
def _run_gmail_agent(
37
    request: RunGmailAgentRequest,
38
    composio_client: ComposioClient,
39
    openai_client: OpenAIClient,  # OpenAI client will be injected as dependency
40
) -> List[ToolExecutionResponse]:
41
    """
42
    Run the Gmail agent for a given user id and prompt.
43
    """
44
    # For demonstration, using a default user_id. Replace with real user logic in production.
45
    user_id = "default"
46
47
    # Validate the user id before proceeding
48
    user_id = validate_user_id(user_id=user_id, composio_client=composio_client)
49
50
    # Run the Gmail agent using Composio and OpenAI
51
    result = run_gmail_agent(
52
        composio_client=composio_client,
53
        openai_client=openai_client,
54
        user_id=user_id,
55
        prompt=request.prompt,
56
    )
57
    return result