This is an automated email from the ASF dual-hosted git repository.
ako pushed a commit to branch new-web
in repository https://gitbox.apache.org/repos/asf/age-website.git
The following commit(s) were added to refs/heads/new-web by this push:
new 17275123 Update blog (#328)
17275123 is described below
commit 172751231fec0f1f658c5af092e5787f15d49a3c
Author: dpdjvhxm <[email protected]>
AuthorDate: Fri Jun 21 23:29:15 2024 +0900
Update blog (#328)
* Test
* Update gatsby-config.js
* Changes search result text
* Fix gatsby-config.js and title
* Change meta description
* Fix sitemap.xml for broken links
* Update landing page: Key Update and image
* Create Blog
“2024-04-21-how-to-integrate-langchain-with-apache-age-for-graph-database-applications”
* Update Blog
“2024-04-21-how-to-integrate-langchain-with-apache-age-for-graph-database-applications”
* Update Blog
“2024-04-21-how-to-integrate-langchain-with-apache-age-for-graph-database-applications”
* Update blog, cms
* Update blog
* Fix spelling error
* Activate "blog"
* Update download page, modified blog
* modified footer, download
* Update landing image and blog scss
* modified: src/components/styles/Blog-post.scss
* modified: src/pages/download/index.md
* modified: src/templates/blog-post.js
* Create Blog
“2024-04-23-beyond-chatgpt-how-to-maximize-the-use-of-chatgpt-with-interactive-graph-models”
* Create Blog
“2024-04-23-combating-cyber-attack-with-apache-ages-link-analysis”
* Create Blog
“2024-04-23-from-data-to-connections-leveraging-hyperconnectivity-in-e-commerce-data-part-1”
* Create Blog
“2024-04-23-learn-machine-learning-with-graph-in-hyperconnected-data-part-2”
* Create Blog “2024-04-23-graph-database-in-postgresql-apache-age”
* Create Blog “2024-04-23-comparison-of-apache-age-postgraphile-and-hasura”
* modified: static/admin/config.yml
* modified: src/components/styles/Blog-post.scss
modified: src/components/styles/BlogRollTemplate.module.scss
modified: src/templates/blog-post.js
* Update Blog “blog_240401”
* Match file name format
* deleted: src/pages/blog/blog_240401.md
* Change button color
* modified: static/sitemap.xml
* modified blog
* modified: src/pages/404.js
modified: src/pages/index.md
* Create Blog
“2024-04-25-discovering-the-inner-workings-of-postgresqls-data-allocation”
* Create Blog
“2024-04-25-seamless-data-migration-migrating-apache-age-data-between-different-versions-of-postgresql”
* Create Blog “2024-04-25-how-to-deploy-apache-age-docker-image-on-aws”
* modified: static/admin/config.yml
* modified: src/pages/blog/
modified:
src/pages/blog/2024-04-25-how-to-deploy-apache-age-docker-image-on-aws.md
modified:
src/pages/blog/2024-04-25-seamless-data-migration-migrating-apache-age-data-between-different-versions-of-postgresql.md
* Create Blog “2024-05-01-what-is-a-graph-database”
* modified: src/templates/blog-post.js
* modified: src/pages/blog/
* modified: src/pages/blog/
* Remove sign®
* modified ™
* Create Blog “2024-05-21-a-dockerhub-guide”
* Create Blog “2024-05-21-a-beginners-guide-to-downloading-docker”
* Create Blog “2024-05-21-basic-understanding-what-is-a-container”
* Create Blog
“2024-05-21-navigating-the-maze-of-data-with-apache-age-and-langchain”
* Create Blog “2024-05-21-how-to-use-the-official-apache-age-docker-image”
* modified blogs
* Update Blog “2024-05-21-a-dockerhub-guide”
* modified BlogRoll
* modified BlogRollTemplate
* new file: static/ads.txt
* Create Blog
“2024-06-12-integrating-apache-age-docker-image-and-pgadmin-4-a-step-by-step-guide”
* Create Blog
“2024-06-12-video-the-easiest-way-to-install-apache-age-docker”
* Add file
* modified and renamed
* modified and renamed
* Create Blog “2024-06-12-video-beginners-guide”
* Create Blog “2024-06-12-video-future-landscape-of-graph-db”
* Update Blog “2024-06-12-video-future-landscape-of-graph-db”
* Create Blog “2024-06-12-video-future-landscape-of-graph-db-1”
* new file and modified
* modified
* renamed
* modified: src/templates/index-page.js
* modified: src/pages/blog/2024-06-12
* renamed
* Create Blog “2024-06-17-integrating-apache-age-with-python”
* Update Blog “2024-06-17-integrating-apache-age-with-python”
* modified
* Create Blog “2024-06-21-video-graph-databases-and-apache-age”
* modified & new file
* modified
* modified
* # This is a combination of 4 commits.
# This is the 1st commit message:
modified
# This is the commit message #2:
Create Blog “2024-06-21-video-graph-databases-and-apache-age”
# This is the commit message #3:
modified & new file
# This is the commit message #4:
modified
* modified
---
...024-06-17-integrating-apache-age-with-python.md | 132 +++++++++++++++++++++
...4-06-21-video-graph-databases-and-apache-age.md | 99 ++++++++++++++++
static/img/f_1.mp4 | Bin 0 -> 19729023 bytes
static/img/f_2.mp4 | Bin 0 -> 46108460 bytes
static/img/f_3.mp4 | Bin 0 -> 34055402 bytes
5 files changed, 231 insertions(+)
diff --git a/src/pages/blog/2024-06-17-integrating-apache-age-with-python.md
b/src/pages/blog/2024-06-17-integrating-apache-age-with-python.md
new file mode 100644
index 00000000..9cddd78b
--- /dev/null
+++ b/src/pages/blog/2024-06-17-integrating-apache-age-with-python.md
@@ -0,0 +1,132 @@
+---
+templateKey: blog-post
+title: Integrating Apache AGE with Python
+date: 2024-06-17T07:00:30.672Z
+description: Integrating Apache AGE with Python
+featuredpost: true
+featuredimage:
+---
+<!--StartFragment-->
+
+Apache AGE (A Graph Extension) is a PostgreSQL extension that provides graph
database functionality. Integrating Apache AGE with Python allows you to
leverage this functionality within your Python applications. This guide will
walk you through the process of setting up the integration and running a sample
code.
+
+#### Prerequisites
+
+For this task, we will use the Apache AGE Docker image.
+
+So before you begin, ensure you have the following installed:
+
+* Docker;
+* Apache AGE image already pulled and executed once (Refer to past tutorials
for this);
+* Python (version 3.9 or later);
+
+You will need psycopg2 and antlr4-python3 packages to run it. You can install
them by executing the requirements.txt file inside the directory
age/drivers/python.
+
+To do so, navigate to the said python driver directory, then run
+
+pip install -r requirements.txt
+
+#### Testing
+
+You can test if everything is working by issuing the command at the same
directory:
+
+```python
+python test_age_py.py \
+ -host "127.0.0.1" \
+ -db "postgres" \
+ -u "postgres" \
+ -pass "agens" \
+ -port 5432 \
+ -gn "test_graph"
+```
+
+<!--EndFragment-->
+
+#### Setup
+
+To use the "age" library, you will need to install it, so, in the same
directory, there's a setup.py file. Execute it with
+
+```
+python setup.py install
+```
+
+Now we're ready to use Apache AGE in Python!
+
+#### Starting the server
+
+But first, be sure to put your postgres server to run. I prefer using Docker,
so issue this command:
+
+```
+docker start age
+```
+
+#### Writing the Python Code
+
+Here is a sample Python script to connect to the PostgreSQL database, create a
graph, and perform basic operations using Apache AGE.
+
+```
+import age
+
+GRAPH_NAME = "test_graph"
+
+"""
+Define the connection parameters (host, port, database name, user, and
password).
+Here, we use the default Apache AGE Docker container settings
+"""
+CONFIG = (
+ "host=127.0.0.1 \
+ port=5455 \
+ dbname=postgresDB \
+ user=postgresUser \
+ password=postgresPW"
+)
+
+try:
+ # Establish a connection to the PostgreSQL database using the defined
parameters.
+ connection = age.connect(graph=GRAPH_NAME, dsn=CONFIG)
+
+ # The Cypher query `CREATE (n:Person {name: 'Maria'}) RETURN n` creates a
node with the label `Person` and a property `name` set to 'Maria'.
+ query = "CREATE (n:Person {name: 'Maria'}) RETURN n"
+
+ # The `execCypher` method sends the query to the database.
+ cursor = connection.execCypher(query)
+
+ # Print the results
+ for row in cursor:
+ print("CREATED: ", row[0])
+
+ # Save the changes to the database.
+ connection.commit()
+
+except Exception as e:
+ print(f"Error: {e}")
+ connection.rollback()
+finally:
+ # Clean up: delete the graph and close the connection
+ age.deleteGraph(connection.connection, GRAPH_NAME)
+ cursor.close()
+ connection.close()
+```
+
+#### Step 4: Running the Script
+
+* Save the code to a file, for example, age_integration.py.
+* Run the script:
+
+```
+python age_integration.py
+```
+
+It should output something close to this:
+
+```
+CREATED: {label:Person, id:844424930131969, properties:{name: Maria,
}}::VERTEX
+```
+
+#### Conclusion
+
+Integrating Apache AGE with Python allows you to utilize powerful graph
database features within your Python applications. By following this guide, you
can set up the integration, run queries, and manage graph data efficiently.
This integration opens up new possibilities for handling complex relationships
and structures in your data.
+
+If you run into any problems, don't hesitate to reach out.
+
+<!--EndFragment-->
\ No newline at end of file
diff --git a/src/pages/blog/2024-06-21-video-graph-databases-and-apache-age.md
b/src/pages/blog/2024-06-21-video-graph-databases-and-apache-age.md
new file mode 100644
index 00000000..0c8fb946
--- /dev/null
+++ b/src/pages/blog/2024-06-21-video-graph-databases-and-apache-age.md
@@ -0,0 +1,99 @@
+---
+templateKey: blog-post
+title: "[ Video ] Graph databases and Apache AGE"
+date: 2024-06-21T01:17:22.666Z
+description:
+featuredpost: true
+featuredimage:
+---
+<div style="display: flex; justify-content: center; align-items: center; ">
+ <video width="960" height="540" controls>
+ <source src="../../../static/img/f_1.mp4" type="video/mp4">
+ Your browser does not support the video tag.
+ </video>
+</div>
+</br>
+
+**1 st : Introduction:**</br>
+Introduction. The rise of graph databases. Data is everywhere. It's the
lifeblood of our digital age,
+but data alone is not enough. We need to understand the relationships within
data to unlock its
+true potential. This is where graph databases come into play. Unlike
traditional databases, graph
+databases excel in understanding connections. They efficiently represent and
query relationships.
+Graph databases are purpose-built for this challenge, ideal for social
networks, recommendation
+engines, and fraud detection. Each user is an entity, and their connections
are the relationships.
+Each user is an entity, and their connections are the relationships. Graph
databases can answer
+complex queries with remarkable speed.
+
+---
+</br>
+
+<div style="display: flex; justify-content: center; align-items: center; ">
+ <video width="960" height="540" controls>
+ <source src="../../../static/img/f_2.mp4" type="video/mp4">
+ Your browser does not support the video tag.
+ </video>
+</div>
+</br>
+
+**2 nd : Understanding the essence of graph structures**</br>
+Understanding the essence of graph structures. At the heart of every graph
database lie three
+fundamental concepts. Nodes, edges and properties. These elements work
together to represent
+and organize data in a way that mirrors the interconnected nature of
information in the real
+world. Understanding these building blocks is key to unlocking the power of
graph databases.
+Nodes, also known as vertices, represent the entities within our data. In a
social network, a node
+could be a user, a post, or a group. In a transportation network, nodes could
represent cities,
+airports, or train stations. Each node encapsulates a distinct piece of
information within the
+graph. Edges, on the other hand, represent the relationships between these
entities. They are the
+connecting lines that establish how nodes interact with each other.
+Returning to our social network example, an edge might signify a friendship
between two users,
+or a likes relationship between a user and a post. Edges give context to nodes
and highlight the
+interconnectedness of our data. Finally, properties provide further details
about nodes and edges.
+They are attributes that enrich our understanding of the entities and
relationships within the
+graph. For instance, a user node might have properties like name, age, and
location, while a
+friendship edge could have properties like date created or connection strength.
+Properties add depth and nuance to our graph representation. Together, nodes,
edges, and
+properties form the basic building blocks of a graph database. They provide a
flexible and
+expressive way to model a wide range of real-world scenarios, from social
networks and
+recommendation engines to fraud detection systems and knowledge graphs. By
understanding
+these fundamental concepts, we can begin to harness the power of graph
databases to unravel the
+complexities hidden within our data. Apache Age, an extension for PostgreSQL
enhances our
+ability to manage and understand complex data relationships.
+By integrating graph database capabilities directly into PostgreSQL, Apache
Edge allows us to
+leverage the strengths of both relational and graph databases. This
integration simplifies the
+process of querying and visualizing complex data relationships, making it
easier to uncover
+insights and patterns. making it easier to uncover insights and patterns.
Whether you're working
+on social networks, recommendation systems, or fraud detection, Apache Age
provides the tools
+needed to enhance your data analysis within PostgreSQL.
+
+---
+</br>
+
+<div style="display: flex; justify-content: center; align-items: center; ">
+ <video width="960" height="540" controls>
+ <source src="../../../static/img/f_3.mp4" type="video/mp4">
+ Your browser does not support the video tag.
+ </video>
+</div>
+</br>
+
+**3 rd : PostgreSQL with Apache Age, a powerful combination.**</br>
+While graph databases offer a compelling approach to managing relationships,
many organizations have existing investments in
+relational databases like PostgreSQL. Fortunately, Apache Age brings the power
of
+graph databases directly into the familiar realm of PostgreSQL, offering a
seamless way to
+integrate graph capabilities into existing SQL-based workflows. Apache Edge
extends
+PostgreSQL with the ability to store, query, and analyze graph data using Open
Cypher, a widely
+adopted graph query language.
+This integration means that developers and data scientists can leverage their
existing SQL skills
+and tools while benefiting from the expressiveness of graph databases. No need
to learn a
+completely new database system or migrate existing data. Installing Apache
Edge on
+PostgreSQL is straightforward, involving simple commands to add the extension
to your
+PostgreSQL instance. Once installed, you can start modeling your data using
familiar graph
+concepts. Define your nodes and edges, specify properties, and begin
populating your graph
+database within the comfortable confines of PostgreSQL. Querying your graph
data is equally
+intuitive. Apache Edge allows you to use Open Cypher queries directly within
your PostgreSQL
+environment.
+This powerful combination enables you to perform complex graph traversals,
pattern matching
+This powerful combination enables you to perform complex graph traversals,
pattern matching
+and analysis, all while leveraging the robustness and familiarity of
PostgreSQL.
+
+</br>
diff --git a/static/img/f_1.mp4 b/static/img/f_1.mp4
new file mode 100644
index 00000000..999fad6d
Binary files /dev/null and b/static/img/f_1.mp4 differ
diff --git a/static/img/f_2.mp4 b/static/img/f_2.mp4
new file mode 100644
index 00000000..237ce254
Binary files /dev/null and b/static/img/f_2.mp4 differ
diff --git a/static/img/f_3.mp4 b/static/img/f_3.mp4
new file mode 100644
index 00000000..f5adaa95
Binary files /dev/null and b/static/img/f_3.mp4 differ
