Resource Description Framework

Resource Description Framework (RDF) is a family of specifications for a metadata model that is often implemented as an application of XML. The RDF family of specifications is maintained by the World Wide Web Consortium (W3C).

The RDF metadata model is based upon the idea of making statements about resources in the form of a subject-predicate-object expression, called a triple in RDF terminology. The subject is the resource, the "thing" being described. The predicate is what trait or aspect about that resource that is being described, and often expresses a relationship between the subject and the object. The object is the object of the relationship or value of that trait.

This mechanism for describing resources is a major component in what is proposed by the W3C's Semantic Web activity: an evolutionary stage of the World Wide Web in which automated software can store, exchange, and utilize metadata about the vast resources of the Web, in turn enabling users to deal with those resources with greater efficiency and certainty. RDF's simple data model and ability to model disparate, abstract concepts has also led to its increasing use in knowledge management applications unrelated to Semantic Web activity.



Work on RDF was initiated by Ramanathan V. Guha while at Apple Computer (as MCF) and continued during his tenure at Netscape Communications Corporation.

The W3C published a specification for RDF's data model and XML syntax as a Recommendation in 1999. Work then began on a new version that was published as a set of related specifications in 2004. Unlike most other W3C Recommendations, the new specifications completely replaced the old, rather than being assigned a version number like "RDF 2.0". Consequently, many implementations based on the 1999 Recommendation have yet to be updated, and many newcomers to RDF are unaware that the older specifications even exist.


A collection of RDF statements intrinsically represents a labelled, directed graph. As such, an RDF-based data model is more naturally suited to certain kinds of knowledge representation than the relational model and other ontological models traditionally used in computing today. However, in practice, RDF data is often stored in relational databases, and as OWL demonstrates, additional ontologies can be built upon RDF.

Query and inference languages

Several query languages for RDF graphs have emerged. RDF query languages allow expressions to be written that can be evaluated against a collection of statements in order to produce, for example, a narrowed set of statements, resources, or object values, or to perform comparisons and operations on such items. RDF queries can be used by knowledge management applications as a basis for inference actions. There is not yet any standard RDF query language; each language is generally tied to a particular implementation.

Resource identification

The subject of an RDF statement is always a resource, as named by a Uniform Resource Identifier (URI). The predicate is a resource representing a relationship, as named by another URI. The object is either a Unicode string literal, or a resource, as named by a URI.

In Semantic Web applications, and in relatively popular applications of RDF like RSS and FOAF, resources tend to be represented by URIs that intentionally denote actual, accessible data on the World Wide Web. But RDF, in general, is not limited to the description of Internet-based resources. In fact, the URI that names a resource does not have to be dereferencable at all. For example, a URI that begins with "http:" and is used as the subject of an RDF statement does not necessarily have to represent a resource that is accessible via HTTP, nor does it need to represent a tangible, network-accessible resource — such a URI could denote the abstract notion of world peace, if desired.

Therefore, it is necessary for producers and consumers of RDF statements to be in agreement on the semantics of resource identifiers. Such agreement is not inherent to RDF itself, although there are some controlled vocabularies in common use, such as Dublin Core Metadata, which is partially mapped to a URI space for use in RDF.


Example 1: The postal abbreviation for New York

Certain concepts in RDF are taken from logic and linguistics, where subject-predicate and subject-predicate-object structures have meanings similar to, yet distinct from, the uses of those terms in RDF. This example demonstrates:

In the English language statement 'New York has a postal abbreviation which is NY' , 'New York' would be the subject, 'postal abbreviation' the predicate and 'NY' the object.

Encoded as an RDF triple, the subject and predicate would have to be resources named by URIs. The object could be a resource or literal string. For example, in the N-Triples form of RDF, the statement might look like:

 <urn:states:New%20York> <> "NY" .

Note: the URIs chosen here are not standard, and don't need to be, as long as their meaning is known to whatever is reading them.

Example 2: A Wikipedia article about Tony Benn

In a like manner, given that "" identifies a particular resource (regardless of whether a representation of the resource is accessible via the HTTP protocol, and regardless of whether the resource is actually the Wikipedia article about Tony Benn), to say that the title of this resource is "Tony Benn" and its publisher is "Wikipedia" would be two assertions that could be expressed as valid RDF statements. In the N-Triples form of RDF, these statements might look like the following:

 <> <> "Tony Benn" .
 <> <> "Wikipedia" .

And these statements might be expressed in RDF/XML as:

<rdf:Description rdf:about="">
  <dc:title>Tony Benn</dc:title>

Why this would be useful in any way is probably not apparent, but the crucial thing to understand is that while "the title of this resource is 'Tony Benn'" might have meaning to a human, it means nothing to a computer. The purpose of RDF is to provide an encoding and interpretation mechanism so that resources can be described in a way that particular software can understand it, or, better put, so that software can more easily access data organized within structured parameters.

It should be understood that software has absolutely no common sense, and can only manipulate symbols within the rules given. It has no way of knowing what a "title" or a "Tony Benn" is.

Both versions of the statements above are wordy because one requirement for a resource (as a subject or a predicate) is that it be unique. It is obvious why the subject resource should be unique. It says what exact resource is being described. The predicate needs to be unique so that the idea of Title or Publisher will not be ambiguous to software working with the description. If the software recognizes (a specific definition for the concept of a title established by the Dublin Core Metadata Initiative), it will also know that this title is different from a land title or an honorary title or just the letters t-i-t-l-e put together.

Statement reification and context

The body of knowledge modeled by a collection of statements may be subjected to reification, in which each statement is assigned a URI and treated as a resource about which additional statements can be made, as in "Jane says that John is the author of document X". Reification is sometimes important in order to deduce a level of confidence or degree of usefulness for each statement.

In a reified RDF database, each original statement, being a resource, itself, most likely has at least three additional statements made about it: one to assert that its subject is some resource, one to assert that its predicate is some resource, and one to assert that its object is some resource or literal. More statements about the original statement may also exist, depending on the application's needs.

Borrowing from concepts introduced in topic maps, some RDF model implementations acknowledge that it is sometimes useful to group statements according to different criteria, called contexts or scopes, as discussed in articles by RDF specification co-editor Graham Klyne [1] ( [2] ( For example, a statement can be associated with a context, named by a URI, in order to assert an "is true in" relationship. As another example, it is sometimes convenient to group statements by their source, which can be identified by a URI, such as the URI of a particular RDF/XML document. Then, when updates are made to the source, corresponding statements can be changed in the model, as well.

Implementation of scopes does not necessarily require fully reified statements. Some implementations allow a single scope identifier to be associated with a statement that has not been assigned a URI, itself. [3] ( [4] (


  • RDF Site Summary - one of several "RSS" languages for publishing information about updates made to a web page; it is often used for disseminating news article summaries and sharing weblog content.
  • FOAF - designed to describe people, their interests and interconnections.

See also

External links

fr:RDF it:RDF nl:Resource Description Framework ja:Resource Description Framework pl:RDF sv:RDF, Resource Description Framework zh:RDF


  • Art and Cultures
    • Art (
    • Architecture (
    • Cultures (
    • Music (
    • Musical Instruments (
  • Biographies (
  • Clipart (
  • Geography (
    • Countries of the World (
    • Maps (
    • Flags (
    • Continents (
  • History (
    • Ancient Civilizations (
    • Industrial Revolution (
    • Middle Ages (
    • Prehistory (
    • Renaissance (
    • Timelines (
    • United States (
    • Wars (
    • World History (
  • Human Body (
  • Mathematics (
  • Reference (
  • Science (
    • Animals (
    • Aviation (
    • Dinosaurs (
    • Earth (
    • Inventions (
    • Physical Science (
    • Plants (
    • Scientists (
  • Social Studies (
    • Anthropology (
    • Economics (
    • Government (
    • Religion (
    • Holidays (
  • Space and Astronomy
    • Solar System (
    • Planets (
  • Sports (
  • Timelines (
  • Weather (
  • US States (


  • Home Page (
  • Contact Us (

  • Clip Art (
Personal tools