template = (
    "You are an expert in Python Developer. Answer the question. <Question>: {input}"
)

# 프롬프트 세팅_1
prompt_1 = ChatPromptTemplate.from_template(template)

# 프롬프트 세팅_2
prompt_2 = ChatPromptTemplate(
    input_variables=["input"],
    messages=[
        HumanMessagePromptTemplate(
            prompt=PromptTemplate(
                input_variables=["input"],
                template=template,
            )
        )
    ],
)

class HumanMessagePromptTemplate(_StringImageMessagePromptTemplate):
    """Human message prompt template. This is a message sent from the user."""

    _msg_class: Type[BaseMessage] = HumanMessage

class AIMessagePromptTemplate(_StringImageMessagePromptTemplate):
    """AI message prompt template. This is a message sent from the AI."""

    _msg_class: Type[BaseMessage] = AIMessage

    @classmethod
    def get_lc_namespace(cls) -> List[str]:
        """Get the namespace of the langchain object."""
        return ["langchain", "prompts", "chat"]

llm = Ollama(model="llama2:latest")
str_output = StrOutputParser()

chain_1 = prompt_1 | llm | str_output
response_1 = chain_1.invoke({"input": "django 와 fastapi 에 대해서 알려줘"})
print("response 1 : ", response_1)
print("*" * 100)
chain_2 = prompt_2 | llm | str_output
response_2 = chain_2.invoke({"input": "django 와 fastapi 에 대해서 알려줘"})
print("response 2 : ", response_2)

response 1 :
Certainly! Django and FastAPI are both popular Python web frameworks, but they have different design principles and use cases. Here's a brief comparison:

Django:

Pros:

1. High-level framework: Django is a mature and well-established framework that provides a lot of built-in functionality, making it easier to build web applications quickly.
2. ORM (Object-Relational Mapping): Django provides an ORM system that simplifies the process of interacting with databases, allowing developers to focus on the application logic rather than the database.
3. Modular architecture: Django has a modular architecture that allows developers to build applications in smaller, more manageable pieces, making it easier to maintain and scale.
4. Large community: Django has a large and active community of developers, which means there are many resources available for learning and troubleshooting.

Cons:

1. Steep learning curve: Django can be challenging to learn, especially for beginners, due to its complex syntax and numerous features.
2. Overkill for small projects: Django is designed for large-scale applications, so it may not be the best choice for smaller projects that don't require its full feature set.
3. Slow development: Due to Django's complexity, developers may find themselves spending more time setting up the framework than actually building the application.

FastAPI:

Pros:

1. Fast and lightweight: FastAPI is designed to be fast and lightweight, making it ideal for small to medium-sized applications.
2. Simplified architecture: FastAPI has a simplified architecture that makes it easier to learn and use, especially for beginners.
3. Easy integration with existing projects: FastAPI can easily integrate with existing Python projects, making it a good choice for developers who want to add web functionality to their existing codebase.
4. Modern design: FastAPI is designed with modern software design principles in mind, making it more flexible and adaptable than older frameworks like Django.

Cons:

1. Limited functionality: FastAPI is a relatively new framework, so it doesn't have as many built-in features as Django. This means developers may need to write more code to accomplish certain tasks.
2. Smaller community: FastAPI has a smaller community of developers compared to Django, which can make it harder to find resources and troubleshoot issues.
3. Less mature ecosystem: FastAPI's ecosystem is still developing, so there may be fewer third-party libraries and tools available compared to Django.

In summary, Django is a more established and comprehensive framework that provides a lot of built-in functionality, but it can also be slower and more complex to use. FastAPI is a newer and more lightweight framework that simplifies the development process, but it may not have as many features or resources available yet. The choice between the two ultimately depends on the specific needs and goals of the project.
****************************************************************************************************
response 2 :
Of course! Django and FastAPI are both popular web frameworks for building web applications using Python. Here's a brief comparison between the two:

Django:

Pros:

1. Maturity: Django is an older framework, first released in 2005, which means it has a more established community and a wider range of libraries and tools available.
2. Ease of use: Django's syntax is easier to learn for beginners, with a simpler structure and more intuitive API.
3. Security: Django has built-in security features such as authentication and access control, which can help protect your application from common web attacks.
4. Community support: Django has a large and active community, with numerous resources available online, including documentation, tutorials, and forums.
5. Rapid development: Django's high-level framework makes it easier to build complex applications quickly.

Cons:

1. Overkill: Django is a full-featured framework that may be overkill for small projects or simple web applications.
2. Steep learning curve: While Django's syntax is easier than some other frameworks, it can still take time to learn and master.
3. Performance overhead: Django's overhead can be higher than some other frameworks due to its extensive library and the use of an ORM (Object-Relational Mapping) system.

FastAPI:

Pros:

1. Lightweight: FastAPI is a modern, lightweight framework that is designed for high-performance applications.
2. Ease of development: FastAPI has a minimalist design philosophy, which means it requires less code to build a web application.
3. Flexibility: FastAPI is built on top of Starlette, which provides a flexible and modular structure.
4. Performance: FastAPI's lightweight design and lack of overhead make it an excellent choice for high-performance applications.
5. Easy integration: FastAPI can easily integrate with other Python libraries and frameworks, such as Django or Flask.

Cons:

1. Learning curve: FastAPI is a relatively new framework, so there may be a steeper learning curve for beginners.
2. Limited community support: While the FastAPI community is growing, it may not have as much documentation and resources available as Django.
3. Security features: FastAPI has fewer built-in security features than Django, which means you may need to implement your own authentication and access control mechanisms.

In summary, Django is a mature and feature-rich framework that is ideal for large and complex applications, while FastAPI is a lightweight and flexible framework that is better suited for smaller projects or those requiring high performance. Ultimately, the choice between the two will depend on your specific needs and preferences.

Process finished with exit code 0