# A QuickStart for AI API Coding
# OpenAI API quick start
# OpenAI API setup
Create OpenAI account and set payment method; Create Project; Create API key in the project on OpenAI (opens new window).
# init Python environment
$ python3 --version
Python 3.11.9
$ pip3 --version
pip 24.0 from /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pip (python 3.11)
$ python3 -m venv .venv
$ source .venv/bin/activate
(.venv) $ pip install openai==1.50.2
# Use OpenAI API
Write a simple Python code to test the OpenAI API.
openai-api.py:
from openai import OpenAI
client = OpenAI()
completion = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{
"role": "user",
"content": "Show me top 5 differences between Java and Python."
}
]
)
print(completion.choices[0].message)
Execute the code:
(.venv) $ export OPENAI_API_KEY="your_api_key_here"
(.venv) $ python src/openai-api.py
Result:
Certainly! Here are the top 5 differences between Java and Python:
Syntax and Readability:
- Python: Python is known for its simple and clean syntax, which emphasizes readability. It uses indentation to define code blocks, which enhances the clarity of code structure.
- Java: Java has a more verbose syntax that requires explicit use of semicolons and braces to define code blocks. This can make Java code longer and arguably more complex compared to Python.
Typing System:
- Python: Python is dynamically typed, meaning that variable types are determined at runtime. You can change a variable’s type during execution without any declarations.
- Java: Java is statically typed, requiring explicit variable declarations and type definitions at compile time. This can help catch type-related errors early but may add to the verbosity of the code.
Performance:
- Python: Generally, Python is slower than Java due to its interpreted nature and dynamic typing. However, for many applications, this speed difference is not significant.
- Java: Java typically performs faster than Python because it is compiled to bytecode and runs on the Java Virtual Machine (JVM), which can optimize performance through Just-In-Time (JIT) compilation.
Memory Management:
- Python: Python uses automatic garbage collection for memory management, which can lead to unpredictable memory usage patterns but simplifies development by managing memory allocation and deallocation automatically.
- Java: Java also features automatic garbage collection but allows programmers more control over memory management through different garbage collectors and memory models.
Use Cases and Ecosystem:
- Python: Python is widely used in data science, machine learning, web development, automation, and scripting due to its rich set of libraries (e.g., NumPy, Pandas, Flask, Django) and simplicity.
- Java: Java is commonly used in large-scale enterprise applications, Android app development, and environments where performance and security are critical. It has a robust ecosystem with frameworks like Spring and Hibernate.
These differences highlight the strengths and weaknesses of each language, helping developers choose the right tool for their specific needs.
# LangChain with OpenAI quick start
# LangChain setup
pip install langchain==0.3.1
pip install langchain-community==0.3.1
pip install langchain-openai==0.2.1
# Use LangChain with OpenAI
Write a simple Python code to test the LangChain with OpenAI.
langchain_openai_quickstart.py:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
model = ChatOpenAI(model="gpt-4o-mini")
messages = [
SystemMessage(content="Translate the following from English into Chinese"),
HumanMessage(content="hi, how are you?"),
]
result = model.invoke(messages)
print(result.content)
Execute the code:
$ python src/langchain_openai_quickstart.py
你好，你好吗？
# LangChain Prompt Template
# prompt template example
from langchain_core.prompts import ChatPromptTemplate
system_template = "Translate the following into {language}:"
prompt_template = ChatPromptTemplate.from_messages(
[("system", system_template), ("user", "{text}")]
)
result_template = prompt_template.invoke({"language": "italian", "text": "hi, how are you?"})
print(result_template)
result_template = prompt_template.invoke({"language": "Chinese", "text": "hi, how are you?"})
print(result_template)
result = model.invoke(result_template)
print(result.content)
Execute the code:
$ python src/langchain_openai_quickstart.py
你好，你好吗？
messages=[SystemMessage(content='Translate the following into italian:', additional_kwargs={}, response_metadata={}), HumanMessage(content='hi, how are you?', additional_kwargs={}, response_metadata={})]
messages=[SystemMessage(content='Translate the following into Chinese:', additional_kwargs={}, response_metadata={}), HumanMessage(content='hi, how are you?', additional_kwargs={}, response_metadata={})]
你好，你好吗？
# LangChain with PGVector quick start
# setup
Download PGVector docker image:
pgvector/pgvector:pg16
Start PGVector docker container:
docker run --name pgvector-container \
-e POSTGRES_USER=langchain -e POSTGRES_PASSWORD=langchain \
-e POSTGRES_DB=langchain -p 6024:5432 -d pgvector/pgvector:pg16
Install Python libs:
pip install -qU langchain_postgres
pip install psycopg_binary
# Python code
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
from langchain_core.documents import Document
from langchain_postgres import PGVector
from langchain_postgres.vectorstores import PGVector
# See docker command above to launch a postgres instance with pgvector enabled.
connection = "postgresql+psycopg://langchain:langchain@localhost:6024/langchain" # Uses psycopg3!
collection_name = "my_docs"
vector_store = PGVector(
embeddings=embeddings,
collection_name=collection_name,
connection=connection,
use_jsonb=True,
)
docs = [
Document(
page_content="there are cats in the pond",
metadata={"id": 1, "location": "pond", "topic": "animals"},
),
Document(
page_content="ducks are also found in the pond",
metadata={"id": 2, "location": "pond", "topic": "animals"},
),
Document(
page_content="fresh apples are available at the market",
metadata={"id": 3, "location": "market", "topic": "food"},
),
Document(
page_content="the market also sells fresh oranges",
metadata={"id": 4, "location": "market", "topic": "food"},
),
Document(
page_content="the new art exhibit is fascinating",
metadata={"id": 5, "location": "museum", "topic": "art"},
),
Document(
page_content="a sculpture exhibit is also at the museum",
metadata={"id": 6, "location": "museum", "topic": "art"},
),
Document(
page_content="a new coffee shop opened on Main Street",
metadata={"id": 7, "location": "Main Street", "topic": "food"},
),
Document(
page_content="the book club meets at the library",
metadata={"id": 8, "location": "library", "topic": "reading"},
),
Document(
page_content="the library hosts a weekly story time for kids",
metadata={"id": 9, "location": "library", "topic": "reading"},
),
Document(
page_content="a cooking class for beginners is offered at the community center",
metadata={"id": 10, "location": "community center", "topic": "classes"},
),
]
vector_store.add_documents(docs, ids=[doc.metadata["id"] for doc in docs])
results = vector_store.similarity_search(
"kitty", k=10, filter={"id": {"$in": [1, 5, 2, 9]}}
)
for doc in results:
print(f"* {doc.page_content} [{doc.metadata}]")
Execute the code:
$ python src/langchain_pgvector_example.py
* there are cats in the pond [{'id': 1, 'topic': 'animals', 'location': 'pond'}]
* the library hosts a weekly story time for kids [{'id': 9, 'topic': 'reading', 'location': 'library'}]
* ducks are also found in the pond [{'id': 2, 'topic': 'animals', 'location': 'pond'}]
* the new art exhibit is fascinating [{'id': 5, 'topic': 'art', 'location': 'museum'}]
References: