Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

Write an advanced math AI in poe. Using modal.…

  1. User

    Write an advanced math AI in poe. Using modal.

    https://creator.poe.com/docs/poe-protocol-specification https://creator.poe.com/docs/accessing-other-bots-on-poe https://creator.poe.com/docs/quick-start https://creator.poe.com/docs/setting-an-introduction-message https://creator.poe.com/docs/accessing-http-request-information https://creator.poe.com/docs/using-openai-function-calling

    Example code: from future import annotations from typing import AsyncIterable from modal import Image, Stub, asgi_app import fastapi_poe as fp

    class GPT35TurboBot(fp.PoeBot): async def get_response( self, request: fp.QueryRequest ) -> AsyncIterable[fp.PartialResponse]: async for msg in fp.stream_request( request, "GPT-3.5-Turbo", request.access_key ): yield msg

    async def get_settings(self, setting: fp.SettingsRequest) -> fp.SettingsResponse:
        return fp.SettingsResponse(server_bot_dependencies={"GPT-3.5-Turbo": 1})
    

    REQUIREMENTS = ["fastapi-poe==0.0.36"] image = Image.debian_slim().pip_install(*REQUIREMENTS) stub = Stub("turbo-example-poe")

    @stub.function(image=image) @asgi_app() def fastapi_app(): bot = GPT35TurboBot() app = fp.make_app(bot, allow_without_key=True) return app

  2. Assistant

    To create an advanced math AI using POE and Modal, we will modify the example code you've provided by focusing the bot's functionality on solving advanced math problems. The key changes include integrating a math solving library or API, and adjusting the bot's response logic to handle math queries effectively.

    We'll use SymPy, a Python library for symbolic mathematics, to handle math operations. If there's a specific external API you'd prefer for mathematical computations, you could integrate it similarly by making HTTP requests within the get_response method. For simplicity, this example will stick to SymPy, which should be installed alongside other requirements.

    Here's how you could write an advanced math AI in POE:

    from __future__ import annotations
    from typing import AsyncIterable
    from modal import Image, Stub, asgi_app
    import fastapi_poe as fp
    import sympy as sp
    
    class AdvancedMathBot(fp.PoeBot):
        async def get_response(
            self, request: fp.QueryRequest
        ) -> AsyncIterable[fp.PartialResponse]:
            # Process the incoming math query using SymPy
            try:
                # Parse the query to a sympy understandable format
                # Here assuming request.query is directly usable, may need adjustment
                result = str(sp.simplify(request.query))
            except Exception as e:
                result = f"Error processing math query: {str(e)}"
            
            # Streaming the result back
            yield fp.PartialResponse(result=result)
        
        async def get_settings(self, setting: fp.SettingsRequest) -> fp.SettingsResponse:
            # Indicating this bot does not have external dependencies
            return fp.SettingsResponse(server_bot_dependencies={})
    
    REQUIREMENTS = ["fastapi-poe==0.0.36", "sympy==1.10.1"]
    image = Image.debian_slim().pip_install(*REQUIREMENTS)
    stub = Stub("advanced-math-example-poe")
    
    @stub.function(image=image)
    @asgi_app()
    def fastapi_app():
        bot = AdvancedMathBot()
        app = fp.make_app(bot, allow_without_key=True)
        return app
    

    In this example, AdvancedMathBot is modified to use SymPy for processing math queries. When a query is received, it attempts to simplify the expression or solve the math problem using sp.simplify(request.query). This is a basic example of utilizing SymPy, and depending on your needs, you might want to leverage more specific functions from SymPy.

    Note: In real use, you might need to parse and sanitize the query before passing it to SymPy to ensure it's in a format SymPy can understand and to mitigate any potential security risks.

    Remember to adjust your requirements and dependencies based on your specific needs, such as if you decide to use an external API for math operations.